@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/cjs/wallet/delegator.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatorManagerImpl = void 0;
+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 networks_1 = require("../networks");
+class DelegatorManagerImpl {
+    constructor(delegatorProvider, arkInfoProvider, identity) {
+        this.delegatorProvider = delegatorProvider;
+        this.arkInfoProvider = arkInfoProvider;
+        this.identity = identity;
+    }
+    async delegate(vtxos, destination, delegateAt) {
+        if (vtxos.length === 0) {
+            return { delegated: [], failed: [] };
+        }
+        const destinationScript = __1.ArkAddress.decode(destination).pkScript;
+        // if explicit delegateAt is provided, delegate all vtxos at once without sorting
+        if (delegateAt) {
+            try {
+                await delegate(this.identity, this.delegatorProvider, this.arkInfoProvider, vtxos, destinationScript, delegateAt);
+            }
+            catch (error) {
+                return { delegated: [], failed: [{ outpoints: vtxos, error }] };
+            }
+            return { delegated: vtxos, failed: [] };
+        }
+        // if no explicit delegateAt is provided, sort vtxos by expiry and delegate in groups of the same expiry day
+        const groupByExpiry = new Map();
+        let recoverableVtxos = [];
+        for (const vtxo of vtxos) {
+            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 vtxos
+        if (groupByExpiry.size === 0) {
+            try {
+                await delegate(this.identity, this.delegatorProvider, this.arkInfoProvider, recoverableVtxos, destinationScript, delegateAt);
+            }
+            catch (error) {
+                return {
+                    delegated: [],
+                    failed: [{ outpoints: recoverableVtxos, error }],
+                };
+            }
+            return { delegated: recoverableVtxos, failed: [] };
+        }
+        // search for the earliest group, include recoverable vtxos 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, this.arkInfoProvider, 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 coins to a delegator provider, allowing them to manage the coins renewal
+ * on behalf of the wallet.
+ * @param vtxos - Array of extended virtual coins 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, arkInfoProvider, 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 vtxos), 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 } = await arkInfoProvider.getInfo();
+    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 } = await delegatorProvider.getDelegateInfo();
+    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);
+    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) {
+    if (delegatePubkey.length === 66) {
+        delegatePubkey = delegatePubkey.slice(2);
+    }
+    const vtxoScript = __1.VtxoScript.decode(input.tapTree);
+    const delegateTapLeaf = vtxoScript.leaves.find((tapLeaf) => {
+        const arkTapscript = (0, __1.decodeTapscript)((0, base_2.scriptFromTapLeafScript)(tapLeaf));
+        if (!__1.MultisigTapscript.is(arkTapscript))
+            return false;
+        if (!arkTapscript.params.pubkeys
+            .map(base_1.hex.encode)
+            .includes(delegatePubkey))
+            return false;
+        return true;
+    });
+    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) {
+    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,
+    };
+}
+function getDayTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    date.setUTCHours(0, 0, 0, 0);
+    return date.getTime();
+}

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineExpoBackgroundTask = defineExpoBackgroundTask;
+exports.registerExpoBackgroundTask = registerExpoBackgroundTask;
+exports.unregisterExpoBackgroundTask = unregisterExpoBackgroundTask;
+const base_1 = require("@scure/base");
+const taskRunner_1 = require("../../worker/expo/taskRunner");
+const processors_1 = require("../../worker/expo/processors");
+const default_1 = require("../../script/default");
+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);
+            // Reconstruct default offchainTapscript as fallback
+            // for VTXOs not associated with a contract.
+            const defaultTapscript = new default_1.DefaultVtxo.Script({
+                pubKey: base_1.hex.decode(config.pubkeyHex),
+                serverPubKey: base_1.hex.decode(config.serverPubKeyHex),
+                csvTimelock: {
+                    value: BigInt(config.exitTimelockValue),
+                    type: config.exitTimelockType,
+                },
+            });
+            await (0, taskRunner_1.runTasks)(taskQueue, processors, {
+                walletRepository,
+                contractRepository,
+                indexerProvider,
+                arkProvider,
+                extendVtxo: (vtxo, contract) => {
+                    if (contract) {
+                        return (0, utils_1.extendVtxoFromContract)(vtxo, contract);
+                    }
+                    return (0, utils_1.extendVirtualCoin)({ offchainTapscript: defaultTapscript }, vtxo);
+                },
+            });
+            // 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 {@link defineExpoBackgroundTask} (typically inside
+ * {@link 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

@@ -0,0 +1,9 @@
+"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

@@ -0,0 +1,231 @@
+"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 {@link 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: SingleKey.fromHex(privateKey),
+ *     arkServerUrl,
+ *     esploraUrl,
+ *     storage: { walletRepository, contractRepository },
+ *     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 {@link Wallet} via `Wallet.create()`.
+     * 2. Wires up processors (defaults to {@link 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) => {
+                if (contract) {
+                    return (0, utils_1.extendVtxoFromContract)(vtxo, contract);
+                }
+                return (0, utils_1.extendVirtualCoin)(wallet, vtxo);
+            },
+        };
+        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
+        }
+    }
+    // ── 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();
+    }
+    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;