@arkade-os/sdk 0.4.27 → 0.4.28

package/dist/esm/wallet/batch.js

@@ -1,180 +0,0 @@
-import { SettlementEventType } from "../providers/ark.js";
-import { TxTree } from "../tree/txTree.js";
-import { hex } from "@scure/base";
-/**
- * Batch namespace provides utilities for joining and processing batch session.
- * The batch settlement process involves multiple events, this namespace provides abstractions and types to handle them.
- * @see https://docs.arkadeos.com/learn/pillars/batch-swaps
- * @example
- * ```typescript
- * // use wallet handler or create a custom one
- * const handler = wallet.createBatchHandler(intentId, inputs, expectedRecipients, musig2session);
- *
- * const abortController = new AbortController();
- * // Get event stream from the Arkade provider
- * const eventStream = arkProvider.getEventStream(
- *   abortController.signal,
- *   ['your-topic-1', 'your-topic-2']
- * );
- *
- * // Join the batch and process events
- * try {
- *   const commitmentTxid = await Batch.join(eventStream, handler);
- *   console.log('Batch completed with commitment:', commitmentTxid);
- * } catch (error) {
- *   console.error('Batch processing failed:', error);
- * } finally {
- *   abortController.abort();
- * }
- * ```
- */
-export var Batch;
-(function (Batch) {
-    // State machine steps for batch session
-    let Step;
-    (function (Step) {
-        Step["Start"] = "start";
-        Step["BatchStarted"] = "batch_started";
-        Step["TreeSigningStarted"] = "tree_signing_started";
-        Step["TreeNoncesAggregated"] = "tree_nonces_aggregated";
-        Step["BatchFinalization"] = "batch_finalization";
-    })(Step || (Step = {}));
-    /**
-     * Start the state machine that will process the batch events and join a batch.
-     * @param eventIterator - The events stream to process.
-     * @param handler - How to react to events.
-     * @param options - Options.
-     */
-    async function join(eventIterator, handler, options = {}) {
-        const { abortController, skipVtxoTreeSigning = false, eventCallback, } = options;
-        let step = Step.Start;
-        // keep track of tree transactions as they arrive
-        const flatVtxoTree = [];
-        const flatConnectorTree = [];
-        // once everything is collected, the TxTree objects are created
-        let vtxoTree = undefined;
-        let connectorTree = undefined;
-        for await (const event of eventIterator) {
-            if (abortController?.signal.aborted) {
-                throw new Error("canceled");
-            }
-            if (eventCallback) {
-                // don't wait for the callback to complete and ignore errors
-                eventCallback(event).catch(() => { });
-            }
-            switch (event.type) {
-                case SettlementEventType.BatchStarted: {
-                    const e = event;
-                    const { skip } = await handler.onBatchStarted(e);
-                    if (!skip) {
-                        step = Step.BatchStarted;
-                        if (skipVtxoTreeSigning) {
-                            // skip TxTree events and musig2 signatures and nonces
-                            step = Step.TreeNoncesAggregated;
-                        }
-                    }
-                    continue;
-                }
-                case SettlementEventType.BatchFinalized: {
-                    if (step !== Step.BatchFinalization) {
-                        continue;
-                    }
-                    if (handler.onBatchFinalized) {
-                        await handler.onBatchFinalized(event);
-                    }
-                    return event.commitmentTxid;
-                }
-                case SettlementEventType.BatchFailed: {
-                    if (handler.onBatchFailed) {
-                        await handler.onBatchFailed(event);
-                        continue;
-                    }
-                    throw new Error(event.reason);
-                }
-                case SettlementEventType.TreeTx: {
-                    if (step !== Step.BatchStarted &&
-                        step !== Step.TreeNoncesAggregated) {
-                        continue;
-                    }
-                    // batchIndex 0 = virtual output tree, batchIndex 1 = connector tree
-                    if (event.batchIndex === 0) {
-                        flatVtxoTree.push(event.chunk);
-                    }
-                    else {
-                        flatConnectorTree.push(event.chunk);
-                    }
-                    if (handler.onTreeTxEvent) {
-                        await handler.onTreeTxEvent(event);
-                    }
-                    continue;
-                }
-                case SettlementEventType.TreeSignature: {
-                    if (step !== Step.TreeNoncesAggregated) {
-                        continue;
-                    }
-                    if (!vtxoTree) {
-                        throw new Error("vtxo tree not initialized");
-                    }
-                    // push signature to the virtual output tree
-                    const tapKeySig = hex.decode(event.signature);
-                    vtxoTree.update(event.txid, (tx) => {
-                        tx.updateInput(0, {
-                            tapKeySig,
-                        });
-                    });
-                    if (handler.onTreeSignatureEvent) {
-                        await handler.onTreeSignatureEvent(event);
-                    }
-                    continue;
-                }
-                case SettlementEventType.TreeSigningStarted: {
-                    if (step !== Step.BatchStarted) {
-                        continue;
-                    }
-                    // create virtual output tree from collected chunks
-                    vtxoTree = TxTree.create(flatVtxoTree);
-                    const { skip } = await handler.onTreeSigningStarted(event, vtxoTree);
-                    if (!skip) {
-                        step = Step.TreeSigningStarted;
-                    }
-                    continue;
-                }
-                case SettlementEventType.TreeNonces: {
-                    if (step !== Step.TreeSigningStarted) {
-                        continue;
-                    }
-                    const { fullySigned } = await handler.onTreeNonces(event);
-                    if (fullySigned) {
-                        step = Step.TreeNoncesAggregated;
-                    }
-                    continue;
-                }
-                case SettlementEventType.BatchFinalization: {
-                    if (step !== Step.TreeNoncesAggregated) {
-                        continue;
-                    }
-                    // Build virtual output tree if it hasn't been built yet
-                    if (!vtxoTree && flatVtxoTree.length > 0) {
-                        vtxoTree = TxTree.create(flatVtxoTree);
-                    }
-                    if (!vtxoTree && !skipVtxoTreeSigning) {
-                        throw new Error("vtxo tree not initialized");
-                    }
-                    // Build connector tree if we have chunks
-                    if (flatConnectorTree.length > 0) {
-                        connectorTree = TxTree.create(flatConnectorTree);
-                    }
-                    await handler.onBatchFinalization(event, vtxoTree, connectorTree);
-                    step = Step.BatchFinalization;
-                    continue;
-                }
-                default:
-                    // unknown event type, continue
-                    continue;
-            }
-        }
-        // iterator closed without finalization, something went wrong
-        throw new Error("event stream closed");
-    }
-    Batch.join = join;
-})(Batch || (Batch = {}));

package/dist/esm/wallet/delegator.js

@@ -1,303 +0,0 @@
-import { ArkAddress, decodeTapscript, Estimator, Intent, isRecoverable, MultisigTapscript, VtxoScript, } from "../index.js";
-import { base64, hex } from "@scure/base";
-import { scriptFromTapLeafScript } from "../script/base.js";
-import { buildForfeitTxWithOutput } from "../forfeit.js";
-import { Address, OutScript, SigHash } from "@scure/btc-signer";
-import { equalBytes } from "@scure/btc-signer/utils.js";
-import { getNetwork } from "../networks.js";
-import { createAssetPacket } from "./asset.js";
-import { Extension } from "../extension/index.js";
-export class DelegatorManagerImpl {
-    /** Create a delegator manager from the configured provider, Arkade info source, and wallet identity. */
-    constructor(delegatorProvider, arkInfoProvider, identity) {
-        this.delegatorProvider = delegatorProvider;
-        this.arkInfoProvider = arkInfoProvider;
-        this.identity = identity;
-    }
-    async getDelegateInfo() {
-        return this.delegatorProvider.getDelegateInfo();
-    }
-    async delegate(vtxos, destination, delegateAt) {
-        if (vtxos.length === 0) {
-            return { delegated: [], failed: [] };
-        }
-        const destinationScript = ArkAddress.decode(destination).pkScript;
-        // fetch server and delegator info once, shared across all groups
-        const arkInfo = await this.arkInfoProvider.getInfo();
-        const delegateInfo = await this.delegatorProvider.getDelegateInfo();
-        // keep only vtxos that can be signed by the delegate. The guard
-        // narrows ContractVtxo (with optional taproot fields) to the
-        // ExtendedVirtualCoin shape required by makeDelegateForfeitTx.
-        const eligible = vtxos.filter((v) => isAnnotated(v) &&
-            findDelegateTapLeaf(v, delegateInfo.pubkey) !== undefined);
-        if (eligible.length === 0) {
-            return { delegated: [], failed: [] };
-        }
-        // if explicit delegateAt is provided, delegate all virtual outputs at once without sorting
-        if (delegateAt) {
-            try {
-                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, eligible, destinationScript, delegateAt);
-            }
-            catch (error) {
-                return {
-                    delegated: [],
-                    failed: [{ outpoints: eligible, error }],
-                };
-            }
-            return { delegated: eligible, failed: [] };
-        }
-        // if no explicit delegateAt is provided, sort virtual outputs by expiry and delegate in groups of the same expiry day
-        const groupByExpiry = new Map();
-        let recoverableVtxos = [];
-        for (const vtxo of eligible) {
-            if (isRecoverable(vtxo)) {
-                recoverableVtxos.push(vtxo);
-                continue;
-            }
-            const expiry = vtxo.virtualStatus.batchExpiry;
-            if (!expiry)
-                continue;
-            const dayKey = getDayTimestamp(expiry);
-            groupByExpiry.set(dayKey, [
-                ...(groupByExpiry.get(dayKey) ?? []),
-                vtxo,
-            ]);
-        }
-        // if no groups, it means we only need to delegate the recoverable virtual outputs
-        if (groupByExpiry.size === 0) {
-            try {
-                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, recoverableVtxos, destinationScript, delegateAt);
-            }
-            catch (error) {
-                return {
-                    delegated: [],
-                    failed: [{ outpoints: recoverableVtxos, error }],
-                };
-            }
-            return { delegated: recoverableVtxos, failed: [] };
-        }
-        // search for the earliest group, include recoverable virtual outputs into it
-        const earliestGroup = Math.min(...groupByExpiry.keys());
-        groupByExpiry.set(earliestGroup, [
-            ...(groupByExpiry.get(earliestGroup) ?? []),
-            ...recoverableVtxos,
-        ]);
-        const groupsList = Array.from(groupByExpiry.entries());
-        const result = await Promise.allSettled(groupsList.map(async ([, vtxosGroup]) => delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, vtxosGroup, destinationScript)));
-        const delegated = [];
-        const failed = [];
-        for (const [index, resultItem] of result.entries()) {
-            const vtxos = groupsList[index][1];
-            if (resultItem.status === "rejected") {
-                failed.push({ outpoints: vtxos, error: resultItem.reason });
-                continue;
-            }
-            delegated.push(...vtxos);
-        }
-        return { delegated, failed };
-    }
-}
-/**
- * Delegates virtual outputs to a delegation service, allowing them to manage their renewal
- * on behalf of the wallet owner.
- * @param vtxos - Array of extended virtual outputs to delegate. Must not be empty.
- * @param delegateAt - Optional Date specifying when the delegation
- *                     should occur. If not provided, defaults to 12 hours before the earliest
- *                     expiry time of the provided vtxos.
- */
-async function delegate(identity, delegatorProvider, arkInfo, delegateInfo, vtxos, destinationScript, delegateAt) {
-    if (vtxos.length === 0) {
-        throw new Error("unable to delegate: no vtxos provided");
-    }
-    if (!delegatorProvider) {
-        throw new Error("unable to delegate: delegator provider not configured");
-    }
-    if (!delegateAt) {
-        const expiryTimestamp = vtxos
-            .filter((coin) => !isRecoverable(coin) && coin.virtualStatus.batchExpiry)
-            .reduce((min, coin) => Math.min(min, coin.virtualStatus.batchExpiry), Number.MAX_SAFE_INTEGER);
-        if (!expiryTimestamp || expiryTimestamp === Number.MAX_SAFE_INTEGER) {
-            // if no expiry (recoverable virtual outputs), delegate 1 minute from now
-            delegateAt = new Date(Date.now() + 1 * 60 * 1000);
-        }
-        else {
-            const remainingTimeMs = expiryTimestamp - Date.now();
-            if (remainingTimeMs <= 0) {
-                delegateAt = new Date(Date.now() + 1 * 60 * 1000);
-            }
-            else {
-                // delegate 10% before the expiry
-                delegateAt = new Date(expiryTimestamp - remainingTimeMs * 0.1);
-            }
-        }
-    }
-    const { fees, dust, forfeitAddress, network } = arkInfo;
-    const delegateAtSeconds = delegateAt.getTime() / 1000;
-    const estimator = new Estimator({
-        ...fees.intentFee,
-        // replace now() function with the delegateAt timestamp
-        offchainInput: fees.intentFee.offchainInput?.replace("now()", `double(${delegateAtSeconds})`),
-        offchainOutput: fees.intentFee.offchainOutput?.replace("now()", `double(${delegateAtSeconds})`),
-    });
-    let amount = 0n;
-    for (const coin of vtxos) {
-        const inputFee = estimator.evalOffchainInput({
-            amount: BigInt(coin.value),
-            type: "vtxo",
-            weight: 0,
-            birth: coin.createdAt,
-            expiry: coin.virtualStatus.batchExpiry
-                ? new Date(coin.virtualStatus.batchExpiry)
-                : undefined,
-        });
-        if (inputFee.value >= coin.value) {
-            continue;
-        }
-        amount += BigInt(coin.value) - BigInt(inputFee.value);
-    }
-    const { delegatorAddress, pubkey, fee } = delegateInfo;
-    const outputs = [];
-    const delegatorFee = BigInt(Number(fee));
-    if (delegatorFee > 0n) {
-        outputs.push({
-            script: ArkAddress.decode(delegatorAddress).pkScript,
-            amount: delegatorFee,
-        });
-    }
-    const outputFee = outputs.reduce((fee, output) => {
-        if (!output.amount || !output.script)
-            return fee;
-        return (fee +
-            estimator.evalOffchainOutput({
-                amount: output.amount,
-                script: hex.encode(output.script),
-            }).satoshis);
-    }, 0);
-    if (amount - BigInt(outputFee) <= dust) {
-        throw new Error("Amount is below dust limit, cannot delegate");
-    }
-    amount -= BigInt(outputFee);
-    amount -= delegatorFee;
-    if (amount <= dust) {
-        throw new Error("Amount is below dust limit, cannot delegate");
-    }
-    outputs.push({
-        script: destinationScript,
-        amount: amount,
-    });
-    const registerIntent = await makeSignedDelegateIntent(identity, vtxos, outputs, [], [pubkey], delegateAtSeconds, destinationScript);
-    const forfeitOutputScript = OutScript.encode(Address(getNetwork(network)).decode(forfeitAddress));
-    const forfeits = await Promise.all(vtxos
-        .filter((v) => !isRecoverable(v))
-        .map(async (coin) => {
-        const forfeit = await makeDelegateForfeitTx(coin, dust, pubkey, forfeitOutputScript, identity);
-        return base64.encode(forfeit.toPSBT());
-    }));
-    await delegatorProvider.delegate(registerIntent, forfeits);
-}
-async function makeDelegateForfeitTx(input, connectorAmount, delegatePubkey, forfeitOutputScript, identity) {
-    const delegateTapLeaf = findDelegateTapLeaf(input, delegatePubkey);
-    if (!delegateTapLeaf) {
-        throw new Error(`delegate tap leaf not found for input: ${input.txid}:${input.vout}`);
-    }
-    const tx = buildForfeitTxWithOutput([
-        {
-            txid: input.txid,
-            index: input.vout,
-            witnessUtxo: {
-                amount: BigInt(input.value),
-                script: VtxoScript.decode(input.tapTree).pkScript,
-            },
-            sighashType: SigHash.ALL_ANYONECANPAY,
-            tapLeafScript: [delegateTapLeaf],
-        },
-    ], {
-        script: forfeitOutputScript,
-        amount: BigInt(input.value) + connectorAmount,
-    });
-    return identity.sign(tx);
-}
-async function makeSignedDelegateIntent(identity, coins, outputs, onchainOutputsIndexes, cosignerPubKeys, validAt, destinationScript) {
-    // if some of the inputs hold assets, build the asset packet and append as output
-    // in the intent proof tx, there is a "fake" input at index 0
-    // so the real coin indices are offset by +1
-    const assetInputs = new Map();
-    for (let i = 0; i < coins.length; i++) {
-        if ("assets" in coins[i]) {
-            const assets = coins[i].assets;
-            if (assets && assets.length > 0) {
-                assetInputs.set(i + 1, assets);
-            }
-        }
-    }
-    let outputAssets;
-    const assetOutputIndex = findDestinationOutputIndex(outputs, destinationScript);
-    if (assetInputs.size > 0) {
-        if (assetOutputIndex === -1) {
-            throw new Error("Cannot assign assets: no output matches the destination address");
-        }
-        // collect all input assets and assign them to the first offchain output
-        const allAssets = new Map();
-        for (const [, assets] of assetInputs) {
-            for (const asset of assets) {
-                const existing = allAssets.get(asset.assetId) ?? 0n;
-                allAssets.set(asset.assetId, existing + asset.amount);
-            }
-        }
-        outputAssets = [];
-        for (const [assetId, amount] of allAssets) {
-            outputAssets.push({ assetId, amount });
-        }
-    }
-    const recipients = outputs.map((output, i) => ({
-        address: "", // not needed for asset packet creation
-        amount: Number(output.amount),
-        assets: i === assetOutputIndex ? outputAssets : undefined,
-    }));
-    if (outputAssets && outputAssets.length > 0) {
-        const assetPacket = createAssetPacket(assetInputs, recipients);
-        outputs.push(Extension.create([assetPacket]).txOut());
-    }
-    const message = {
-        type: "register",
-        onchain_output_indexes: onchainOutputsIndexes,
-        valid_at: Math.floor(validAt),
-        expire_at: 0,
-        cosigners_public_keys: cosignerPubKeys,
-    };
-    const proof = Intent.create(message, coins, outputs);
-    const signedProof = await identity.sign(proof);
-    return {
-        proof: base64.encode(signedProof.toPSBT()),
-        message,
-    };
-}
-/**
- * Finds the index of the output whose script matches the destination script.
- * Returns -1 if no match is found.
- */
-export function findDestinationOutputIndex(outputs, destinationScript) {
-    return outputs.findIndex((o) => o.script && equalBytes(o.script, destinationScript));
-}
-function getDayTimestamp(timestamp) {
-    const date = new Date(timestamp);
-    date.setUTCHours(0, 0, 0, 0);
-    return date.getTime();
-}
-function findDelegateTapLeaf(vtxo, delegatePubkey) {
-    if (!vtxo.tapTree)
-        return undefined;
-    const pk = delegatePubkey.length === 66 ? delegatePubkey.slice(2) : delegatePubkey;
-    const vtxoScript = VtxoScript.decode(vtxo.tapTree);
-    return vtxoScript.leaves.find((tapLeaf) => {
-        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
-        if (!MultisigTapscript.is(arkTapscript))
-            return false;
-        return arkTapscript.params.pubkeys.map(hex.encode).includes(pk);
-    });
-}
-function isAnnotated(v) {
-    return (v.tapTree !== undefined &&
-        v.forfeitTapLeafScript !== undefined &&
-        v.intentTapLeafScript !== undefined);
-}

package/dist/esm/wallet/expo/background.js

@@ -1,111 +0,0 @@
-import { runTasks, createTaskDependencies } from "../../worker/expo/taskRunner.js";
-import { contractPollProcessor, CONTRACT_POLL_TASK_TYPE, } from "../../worker/expo/processors/index.js";
-import { ExpoArkProvider } from "../../providers/expoArk.js";
-import { ExpoIndexerProvider } from "../../providers/expoIndexer.js";
-import { getRandomId } from "../utils.js";
-function requireTaskManager() {
-    try {
-        return require("expo-task-manager");
-    }
-    catch {
-        throw new Error("expo-task-manager is required for background tasks. " +
-            "Install it with: npx expo install expo-task-manager");
-    }
-}
-function requireBackgroundTask() {
-    try {
-        return require("expo-background-task");
-    }
-    catch {
-        throw new Error("expo-background-task is required for background tasks. " +
-            "Install it with: npx expo install expo-background-task");
-    }
-}
-/**
- * Define the Expo background task handler.
- *
- * **Must be called at module/global scope** (before React mounts).
- * Internally calls `TaskManager.defineTask()`.
- *
- * @example
- * ```ts
- * // At the top of your app entry file
- * import { defineExpoBackgroundTask } from "@arkade-os/sdk/wallet/expo";
- * import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
- * import AsyncStorage from "@react-native-async-storage/async-storage";
- *
- * const taskQueue = new AsyncStorageTaskQueue(AsyncStorage);
- * defineExpoBackgroundTask("ark-background-poll", {
- *     taskQueue,
- *     walletRepository: new IndexedDBWalletRepository(),
- *     contractRepository: new IndexedDBContractRepository(),
- * });
- * ```
- */
-export function defineExpoBackgroundTask(taskName, options) {
-    const TaskManager = requireTaskManager();
-    const BackgroundTask = requireBackgroundTask();
-    const { taskQueue, walletRepository, contractRepository, processors = [contractPollProcessor], } = options;
-    TaskManager.defineTask(taskName, async () => {
-        try {
-            const config = await taskQueue.loadConfig();
-            if (!config) {
-                // No config persisted yet — ExpoWallet.setup() hasn't run.
-                // Nothing to do.
-                return BackgroundTask.BackgroundTaskResult.Success;
-            }
-            // Reconstruct providers
-            const indexerProvider = new ExpoIndexerProvider(config.arkServerUrl);
-            const arkProvider = new ExpoArkProvider(config.arkServerUrl);
-            const deps = createTaskDependencies({
-                walletRepository,
-                contractRepository,
-                indexerProvider,
-                arkProvider,
-            });
-            await runTasks(taskQueue, processors, deps);
-            // Acknowledge outbox results (no foreground to consume them)
-            const results = await taskQueue.getResults();
-            if (results.length > 0) {
-                await taskQueue.acknowledgeResults(results.map((r) => r.id));
-            }
-            // Re-seed the contract-poll task for the next OS wake
-            const existing = await taskQueue.getTasks(CONTRACT_POLL_TASK_TYPE);
-            if (existing.length === 0) {
-                const task = {
-                    id: getRandomId(),
-                    type: CONTRACT_POLL_TASK_TYPE,
-                    data: {},
-                    createdAt: Date.now(),
-                };
-                await taskQueue.addTask(task);
-            }
-            return BackgroundTask.BackgroundTaskResult.Success;
-        }
-        catch (error) {
-            console.error("[ark-sdk] Background task failed:", error instanceof Error ? error.message : error);
-            return BackgroundTask.BackgroundTaskResult.Failed;
-        }
-    });
-}
-/**
- * Activate the OS-level background task scheduler.
- *
- * Call this after @see defineExpoBackgroundTask (typically inside
- * @see ExpoWallet.setup or in a React component after wallet init).
- *
- * @param minimumInterval - Minimum interval in minutes (default 15).
- */
-export async function registerExpoBackgroundTask(taskName, options) {
-    const BackgroundTask = requireBackgroundTask();
-    await BackgroundTask.registerTaskAsync(taskName, {
-        minimumInterval: (options?.minimumInterval ?? 15) * 60,
-    });
-}
-/**
- * Unregister the background task from the OS scheduler.
- */
-export async function unregisterExpoBackgroundTask(taskName) {
-    const BackgroundTask = requireBackgroundTask();
-    await BackgroundTask.unregisterTaskAsync(taskName);
-}

package/dist/esm/wallet/expo/index.js

@@ -1,2 +0,0 @@
-export { ExpoWallet } from "./wallet.js";
-export { defineExpoBackgroundTask, registerExpoBackgroundTask, unregisterExpoBackgroundTask, } from "./background.js";