@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/cjs/wallet/delegator.js

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DelegatorManagerImpl = void 0;
-exports.findDestinationOutputIndex = findDestinationOutputIndex;
-const __1 = require("..");
-const base_1 = require("@scure/base");
-const base_2 = require("../script/base");
-const forfeit_1 = require("../forfeit");
-const btc_signer_1 = require("@scure/btc-signer");
-const utils_js_1 = require("@scure/btc-signer/utils.js");
-const networks_1 = require("../networks");
-const asset_1 = require("./asset");
-const extension_1 = require("../extension");
-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 = __1.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
-        const eligible = vtxos
-            .filter((v) => findDelegateTapLeaf(v, delegateInfo.pubkey) !== undefined)
-            .map((v) => v);
-        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 ((0, __1.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 };
-    }
-}
-exports.DelegatorManagerImpl = DelegatorManagerImpl;
-/**
- * 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) => !(0, __1.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 __1.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: __1.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: base_1.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 = btc_signer_1.OutScript.encode((0, btc_signer_1.Address)((0, networks_1.getNetwork)(network)).decode(forfeitAddress));
-    const forfeits = await Promise.all(vtxos
-        .filter((v) => !(0, __1.isRecoverable)(v))
-        .map(async (coin) => {
-        const forfeit = await makeDelegateForfeitTx(coin, dust, pubkey, forfeitOutputScript, identity);
-        return base_1.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 = (0, forfeit_1.buildForfeitTxWithOutput)([
-        {
-            txid: input.txid,
-            index: input.vout,
-            witnessUtxo: {
-                amount: BigInt(input.value),
-                script: __1.VtxoScript.decode(input.tapTree).pkScript,
-            },
-            sighashType: btc_signer_1.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 = (0, asset_1.createAssetPacket)(assetInputs, recipients);
-        outputs.push(extension_1.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 = __1.Intent.create(message, coins, outputs);
-    const signedProof = await identity.sign(proof);
-    return {
-        proof: base_1.base64.encode(signedProof.toPSBT()),
-        message,
-    };
-}
-/**
- * Finds the index of the output whose script matches the destination script.
- * Returns -1 if no match is found.
- */
-function findDestinationOutputIndex(outputs, destinationScript) {
-    return outputs.findIndex((o) => o.script && (0, utils_js_1.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 = __1.VtxoScript.decode(vtxo.tapTree);
-    return vtxoScript.leaves.find((tapLeaf) => {
-        const arkTapscript = (0, __1.decodeTapscript)((0, base_2.scriptFromTapLeafScript)(tapLeaf));
-        if (!__1.MultisigTapscript.is(arkTapscript))
-            return false;
-        return arkTapscript.params.pubkeys.map(base_1.hex.encode).includes(pk);
-    });
-}

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

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineExpoBackgroundTask = defineExpoBackgroundTask;
-exports.registerExpoBackgroundTask = registerExpoBackgroundTask;
-exports.unregisterExpoBackgroundTask = unregisterExpoBackgroundTask;
-const taskRunner_1 = require("../../worker/expo/taskRunner");
-const processors_1 = require("../../worker/expo/processors");
-const expoArk_1 = require("../../providers/expoArk");
-const expoIndexer_1 = require("../../providers/expoIndexer");
-const utils_1 = require("../utils");
-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(),
- * });
- * ```
- */
-function defineExpoBackgroundTask(taskName, options) {
-    const TaskManager = requireTaskManager();
-    const BackgroundTask = requireBackgroundTask();
-    const { taskQueue, walletRepository, contractRepository, processors = [processors_1.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 expoIndexer_1.ExpoIndexerProvider(config.arkServerUrl);
-            const arkProvider = new expoArk_1.ExpoArkProvider(config.arkServerUrl);
-            const deps = (0, taskRunner_1.createTaskDependencies)({
-                walletRepository,
-                contractRepository,
-                indexerProvider,
-                arkProvider,
-            });
-            await (0, taskRunner_1.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(processors_1.CONTRACT_POLL_TASK_TYPE);
-            if (existing.length === 0) {
-                const task = {
-                    id: (0, utils_1.getRandomId)(),
-                    type: processors_1.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).
- */
-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.
- */
-async function unregisterExpoBackgroundTask(taskName) {
-    const BackgroundTask = requireBackgroundTask();
-    await BackgroundTask.unregisterTaskAsync(taskName);
-}

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

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unregisterExpoBackgroundTask = exports.registerExpoBackgroundTask = exports.defineExpoBackgroundTask = exports.ExpoWallet = void 0;
-var wallet_1 = require("./wallet");
-Object.defineProperty(exports, "ExpoWallet", { enumerable: true, get: function () { return wallet_1.ExpoWallet; } });
-var background_1 = require("./background");
-Object.defineProperty(exports, "defineExpoBackgroundTask", { enumerable: true, get: function () { return background_1.defineExpoBackgroundTask; } });
-Object.defineProperty(exports, "registerExpoBackgroundTask", { enumerable: true, get: function () { return background_1.registerExpoBackgroundTask; } });
-Object.defineProperty(exports, "unregisterExpoBackgroundTask", { enumerable: true, get: function () { return background_1.unregisterExpoBackgroundTask; } });

package/dist/cjs/wallet/expo/wallet.js

@@ -1,230 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpoWallet = void 0;
-const base_1 = require("@scure/base");
-const wallet_1 = require("../wallet");
-const ark_1 = require("../../providers/ark");
-const taskRunner_1 = require("../../worker/expo/taskRunner");
-const processors_1 = require("../../worker/expo/processors");
-const utils_1 = require("../utils");
-const default_1 = require("../../script/default");
-/**
- * Expo/React Native wallet with built-in background task processing.
- *
- * Wraps a standard @see Wallet and adds a lightweight task queue
- * for keeping contract/VTXO state fresh while the app is active and
- * across Expo BackgroundTask wakes.
- *
- * @example
- * ```ts
- * import { ExpoWallet } from "@arkade-os/sdk/wallet/expo";
- * import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
- *
- * const wallet = await ExpoWallet.setup({
- *     identity: MnemonicIdentity.fromMnemonic('abandon abandon...'),
- *     arkServerUrl: 'https://arkade.computer',
- *     esploraUrl: 'https://mempool.space/api',
- *     storage: { ... },
- *     background: {
- *         taskName: "ark-background-poll",
- *         taskQueue: new AsyncStorageTaskQueue(AsyncStorage),
- *         foregroundIntervalMs: 20_000,
- *         minimumBackgroundInterval: 15,
- *     },
- * });
- *
- * const balance = await wallet.getBalance();
- * ```
- */
-class ExpoWallet {
-    constructor(wallet, taskQueue, processors, deps, taskName, foregroundIntervalMs) {
-        this.wallet = wallet;
-        this.taskQueue = taskQueue;
-        this.processors = processors;
-        this.deps = deps;
-        this.identity = wallet.identity;
-        this.arkProvider = wallet.arkProvider;
-        this.indexerProvider = wallet.indexerProvider;
-        this.taskName = taskName;
-        if (foregroundIntervalMs && foregroundIntervalMs > 0) {
-            this.startForegroundPolling(foregroundIntervalMs);
-        }
-    }
-    /**
-     * Create an ExpoWallet with background task support.
-     *
-     * 1. Creates the inner @see Wallet via `Wallet.create()`.
-     * 2. Wires up processors (defaults to @see contractPollProcessor).
-     * 3. Persists background config for the background handler (if the queue supports it).
-     * 4. Seeds the task queue with a `contract-poll` task.
-     * 5. Registers the background task with the OS scheduler (if `minimumBackgroundInterval` is set).
-     * 6. Starts foreground polling if `foregroundIntervalMs` is set.
-     */
-    static async setup(config) {
-        const wallet = await wallet_1.Wallet.create(config);
-        const processors = config.background.processors ?? [
-            processors_1.contractPollProcessor,
-        ];
-        const deps = {
-            walletRepository: wallet.walletRepository,
-            contractRepository: wallet.contractRepository,
-            indexerProvider: wallet.indexerProvider,
-            arkProvider: wallet.arkProvider,
-            extendVtxo: (vtxo, contract) => (0, utils_1.extendVirtualCoinForContract)(vtxo, contract),
-        };
-        const { taskQueue } = config.background;
-        // Persist wallet params so the background handler can rehydrate
-        // without a network call. Only works with AsyncStorageTaskQueue.
-        if ("persistConfig" in taskQueue) {
-            const arkServerUrl = config.arkServerUrl ??
-                (wallet.arkProvider instanceof ark_1.RestArkProvider
-                    ? wallet.arkProvider.serverUrl
-                    : undefined);
-            if (arkServerUrl) {
-                const timelock = wallet.offchainTapscript.options.csvTimelock ??
-                    default_1.DefaultVtxo.Script.DEFAULT_TIMELOCK;
-                const bgConfig = {
-                    arkServerUrl,
-                    pubkeyHex: base_1.hex.encode(wallet.offchainTapscript.options.pubKey),
-                    serverPubKeyHex: base_1.hex.encode(wallet.offchainTapscript.options.serverPubKey),
-                    exitTimelockValue: timelock.value.toString(),
-                    exitTimelockType: timelock.type,
-                };
-                await taskQueue.persistConfig(bgConfig);
-            }
-        }
-        const expoWallet = new ExpoWallet(wallet, taskQueue, processors, deps, config.background.taskName, config.background.foregroundIntervalMs);
-        // Seed the queue so the first tick (or background wake) has work to do
-        await expoWallet.seedContractPollTask();
-        // Activate OS-level background scheduling
-        if (config.background.minimumBackgroundInterval) {
-            try {
-                const { registerExpoBackgroundTask } = await Promise.resolve().then(() => __importStar(require("./background")));
-                await registerExpoBackgroundTask(config.background.taskName, {
-                    minimumInterval: config.background.minimumBackgroundInterval,
-                });
-            }
-            catch {
-                // expo-background-task not installed — foreground-only mode
-            }
-        }
-        return expoWallet;
-    }
-    // ── Foreground polling ───────────────────────────────────────────
-    startForegroundPolling(intervalMs) {
-        this.foregroundIntervalId = setInterval(() => {
-            this.runForegroundPoll().catch(console.error);
-        }, intervalMs);
-    }
-    async runForegroundPoll() {
-        await (0, taskRunner_1.runTasks)(this.taskQueue, this.processors, this.deps);
-        // Consume results immediately (no background handoff needed)
-        const results = await this.taskQueue.getResults();
-        if (results.length > 0) {
-            await this.taskQueue.acknowledgeResults(results.map((r) => r.id));
-        }
-        // Re-seed for the next tick
-        await this.seedContractPollTask();
-    }
-    async seedContractPollTask() {
-        const existing = await this.taskQueue.getTasks(processors_1.CONTRACT_POLL_TASK_TYPE);
-        if (existing.length > 0)
-            return;
-        const task = {
-            id: (0, utils_1.getRandomId)(),
-            type: processors_1.CONTRACT_POLL_TASK_TYPE,
-            data: {},
-            createdAt: Date.now(),
-        };
-        await this.taskQueue.addTask(task);
-    }
-    // ── Lifecycle ────────────────────────────────────────────────────
-    /**
-     * Stop foreground polling and unregister the background task.
-     */
-    async dispose() {
-        if (this.foregroundIntervalId) {
-            clearInterval(this.foregroundIntervalId);
-            this.foregroundIntervalId = undefined;
-        }
-        try {
-            const { unregisterExpoBackgroundTask } = await Promise.resolve().then(() => __importStar(require("./background")));
-            await unregisterExpoBackgroundTask(this.taskName);
-        }
-        catch {
-            // expo-background-task not installed — nothing to unregister
-        }
-        await this.wallet.dispose();
-    }
-    // ── IWallet delegation ───────────────────────────────────────────
-    getAddress() {
-        return this.wallet.getAddress();
-    }
-    getBoardingAddress() {
-        return this.wallet.getBoardingAddress();
-    }
-    getBalance() {
-        return this.wallet.getBalance();
-    }
-    getVtxos(filter) {
-        return this.wallet.getVtxos(filter);
-    }
-    getBoardingUtxos() {
-        return this.wallet.getBoardingUtxos();
-    }
-    getTransactionHistory() {
-        return this.wallet.getTransactionHistory();
-    }
-    getContractManager() {
-        return this.wallet.getContractManager();
-    }
-    getDelegatorManager() {
-        return this.wallet.getDelegatorManager();
-    }
-    sendBitcoin(params) {
-        return this.wallet.sendBitcoin(params);
-    }
-    settle(params, eventCallback) {
-        return this.wallet.settle(params, eventCallback);
-    }
-    send(...recipients) {
-        return this.wallet.send(...recipients);
-    }
-    get assetManager() {
-        return this.wallet.assetManager;
-    }
-}
-exports.ExpoWallet = ExpoWallet;