@arkade-os/sdk 0.4.0 → 0.4.2

package/dist/cjs/wallet/delegator.js

@@ -7,6 +7,8 @@ const base_2 = require("../script/base");
 const forfeit_1 = require("../forfeit");
 const btc_signer_1 = require("@scure/btc-signer");
 const networks_1 = require("../networks");
+const asset_1 = require("./asset");
+const extension_1 = require("../extension");
 class DelegatorManagerImpl {
     constructor(delegatorProvider, arkInfoProvider, identity) {
         this.delegatorProvider = delegatorProvider;
@@ -217,6 +219,48 @@ async function makeDelegateForfeitTx(input, connectorAmount, delegatePubkey, for
     return identity.sign(tx);
 }
 async function makeSignedDelegateIntent(identity, coins, outputs, onchainOutputsIndexes, cosignerPubKeys, validAt) {
+    // 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;
+    let assetOutputIndex; // where to send the assets
+    if (assetInputs.size > 0) {
+        // 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 + BigInt(asset.amount));
+            }
+        }
+        outputAssets = [];
+        for (const [assetId, amount] of allAssets) {
+            outputAssets.push({ assetId, amount: Number(amount) });
+        }
+        const firstOffchainIndex = outputs.findIndex((_, i) => !onchainOutputsIndexes.includes(i));
+        if (firstOffchainIndex === -1) {
+            throw new Error("Cannot settle assets without an offchain output");
+        }
+        assetOutputIndex = firstOffchainIndex;
+    }
+    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,

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

@@ -66,7 +66,7 @@ function defineExpoBackgroundTask(taskName, options) {
             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({
+            const offchainTapscript = new default_1.DefaultVtxo.Script({
                 pubKey: base_1.hex.decode(config.pubkeyHex),
                 serverPubKey: base_1.hex.decode(config.serverPubKeyHex),
                 csvTimelock: {
@@ -74,18 +74,14 @@ function defineExpoBackgroundTask(taskName, options) {
                     type: config.exitTimelockType,
                 },
             });
-            await (0, taskRunner_1.runTasks)(taskQueue, processors, {
+            const deps = (0, taskRunner_1.createTaskDependencies)({
                 walletRepository,
                 contractRepository,
                 indexerProvider,
                 arkProvider,
-                extendVtxo: (vtxo, contract) => {
-                    if (contract) {
-                        return (0, utils_1.extendVtxoFromContract)(vtxo, contract);
-                    }
-                    return (0, utils_1.extendVirtualCoin)({ offchainTapscript: defaultTapscript }, vtxo);
-                },
+                offchainTapscript,
             });
+            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) {

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTRACT_POLL_TASK_TYPE = exports.contractPollProcessor = exports.runTasks = exports.AsyncStorageTaskQueue = exports.InMemoryTaskQueue = void 0;
+exports.CONTRACT_POLL_TASK_TYPE = exports.contractPollProcessor = exports.createTaskDependencies = exports.runTasks = exports.AsyncStorageTaskQueue = exports.InMemoryTaskQueue = void 0;
 var taskQueue_1 = require("./taskQueue");
 Object.defineProperty(exports, "InMemoryTaskQueue", { enumerable: true, get: function () { return taskQueue_1.InMemoryTaskQueue; } });
 var asyncStorageTaskQueue_1 = require("./asyncStorageTaskQueue");
 Object.defineProperty(exports, "AsyncStorageTaskQueue", { enumerable: true, get: function () { return asyncStorageTaskQueue_1.AsyncStorageTaskQueue; } });
 var taskRunner_1 = require("./taskRunner");
 Object.defineProperty(exports, "runTasks", { enumerable: true, get: function () { return taskRunner_1.runTasks; } });
+Object.defineProperty(exports, "createTaskDependencies", { enumerable: true, get: function () { return taskRunner_1.createTaskDependencies; } });
 var processors_1 = require("./processors");
 Object.defineProperty(exports, "contractPollProcessor", { enumerable: true, get: function () { return processors_1.contractPollProcessor; } });
 Object.defineProperty(exports, "CONTRACT_POLL_TASK_TYPE", { enumerable: true, get: function () { return processors_1.CONTRACT_POLL_TASK_TYPE; } });

package/dist/cjs/worker/expo/taskRunner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runTasks = runTasks;
+exports.createTaskDependencies = createTaskDependencies;
 const utils_1 = require("../../wallet/utils");
 /**
  * Run all pending tasks from the queue through matching processors.
@@ -55,3 +56,27 @@ async function runTasks(queue, processors, deps) {
     }
     return results;
 }
+/**
+ * Build the {@link TaskDependencies} needed by task processors
+ * (e.g. {@link import("./processors").contractPollProcessor}).
+ *
+ * This is the same construction that `defineExpoBackgroundTask` does
+ * internally, extracted so that consumers with custom schedulers
+ * (e.g. bare React Native with `react-native-background-fetch`)
+ * can build deps without depending on Expo.
+ */
+function createTaskDependencies(options) {
+    const { walletRepository, contractRepository, indexerProvider, arkProvider, offchainTapscript, } = options;
+    return {
+        walletRepository,
+        contractRepository,
+        indexerProvider,
+        arkProvider,
+        extendVtxo: (vtxo, contract) => {
+            if (contract) {
+                return (0, utils_1.extendVtxoFromContract)(vtxo, contract);
+            }
+            return (0, utils_1.extendVirtualCoin)({ offchainTapscript }, vtxo);
+        },
+    };
+}

package/dist/cjs/worker/messageBus.js

@@ -9,7 +9,7 @@ const identity_1 = require("../identity");
 const wallet_1 = require("../wallet/wallet");
 const base_1 = require("@scure/base");
 class MessageBus {
-    constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, debug = false, buildServices, }) {
+    constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, messageTimeoutMs = 30000, debug = false, buildServices, }) {
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
         this.running = false;
@@ -17,8 +17,10 @@ class MessageBus {
         this.tickInProgress = false;
         this.debug = false;
         this.initialized = false;
+        this.boundOnMessage = this.onMessage.bind(this);
         this.handlers = new Map(messageHandlers.map((u) => [u.messageTag, u]));
         this.tickIntervalMs = tickIntervalMs;
+        this.messageTimeoutMs = messageTimeoutMs;
         this.debug = debug;
         this.buildServicesFn = buildServices ?? this.buildServices.bind(this);
     }
@@ -29,7 +31,7 @@ class MessageBus {
         if (this.debug)
             console.log("MessageBus starting");
         // Hook message routing
-        self.addEventListener("message", this.onMessage.bind(this));
+        self.addEventListener("message", this.boundOnMessage);
         // activate service worker immediately
         self.addEventListener("install", () => {
             self.skipWaiting();
@@ -52,7 +54,7 @@ class MessageBus {
             self.clearTimeout(this.tickTimeout);
             this.tickTimeout = null;
         }
-        self.removeEventListener("message", this.onMessage.bind(this));
+        self.removeEventListener("message", this.boundOnMessage);
         await Promise.all(Array.from(this.handlers.values()).map((updater) => updater.stop()));
     }
     scheduleNextTick() {
@@ -78,7 +80,7 @@ class MessageBus {
             const now = Date.now();
             for (const updater of this.handlers.values()) {
                 try {
-                    const response = await updater.tick(now);
+                    const response = await this.withTimeout(updater.tick(now), `${updater.messageTag}:tick`);
                     if (this.debug)
                         console.log(`[${updater.messageTag}] outgoing tick response:`, response);
                     if (response && response.length > 0) {
@@ -169,12 +171,25 @@ class MessageBus {
             throw new Error("Missing privateKey or publicKey in configuration object");
         }
     }
-    async onMessage(event) {
+    onMessage(event) {
+        // Keep the service worker alive while async work is pending.
+        // Without this, the browser may terminate the SW mid-operation,
+        // causing all pending responses to be lost silently.
+        const promise = this.processMessage(event);
+        if (typeof event.waitUntil === "function") {
+            event.waitUntil(promise);
+        }
+        return promise;
+    }
+    async processMessage(event) {
         const { id, tag, broadcast } = event.data;
         if (tag === "INITIALIZE_MESSAGE_BUS") {
             if (this.debug) {
                 console.log("Init Command received");
             }
+            // Intentionally not wrapped with withTimeout: initialization
+            // performs network calls (buildServices) and handler startup
+            // that may legitimately exceed the message timeout.
             await this.waitForInit(event.data.config);
             event.source?.postMessage({ id, tag });
             if (this.debug) {
@@ -208,7 +223,7 @@ class MessageBus {
         }
         if (broadcast) {
             const updaters = Array.from(this.handlers.values());
-            const results = await Promise.allSettled(updaters.map((updater) => updater.handleMessage(event.data)));
+            const results = await Promise.allSettled(updaters.map((updater) => this.withTimeout(updater.handleMessage(event.data), updater.messageTag)));
             results.forEach((result, index) => {
                 const updater = updaters[index];
                 if (result.status === "fulfilled") {
@@ -239,7 +254,7 @@ class MessageBus {
             return;
         }
         try {
-            const response = await updater.handleMessage(event.data);
+            const response = await this.withTimeout(updater.handleMessage(event.data), tag);
             if (this.debug)
                 console.log(`[${tag}] outgoing response:`, response);
             if (response) {
@@ -253,6 +268,27 @@ class MessageBus {
             event.source?.postMessage({ id, tag, error });
         }
     }
+    /**
+     * Race `promise` against a timeout. Note: this does NOT cancel the
+     * underlying work — the original promise keeps running. This is safe
+     * here because only the caller (not the handler) posts the response.
+     */
+    withTimeout(promise, label) {
+        if (this.messageTimeoutMs <= 0)
+            return promise;
+        return new Promise((resolve, reject) => {
+            const timer = self.setTimeout(() => {
+                reject(new Error(`Message handler timed out after ${this.messageTimeoutMs}ms (${label})`));
+            }, this.messageTimeoutMs);
+            promise.then((val) => {
+                self.clearTimeout(timer);
+                resolve(val);
+            }, (err) => {
+                self.clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
     /**
      * Returns the registered SW for the path.
      * It uses the functions in `service-worker-manager.ts` module.

package/dist/esm/wallet/delegator.js

@@ -4,6 +4,8 @@ import { scriptFromTapLeafScript } from '../script/base.js';
 import { buildForfeitTxWithOutput } from '../forfeit.js';
 import { Address, OutScript, SigHash } from "@scure/btc-signer";
 import { getNetwork } from '../networks.js';
+import { createAssetPacket } from './asset.js';
+import { Extension } from '../extension/index.js';
 export class DelegatorManagerImpl {
     constructor(delegatorProvider, arkInfoProvider, identity) {
         this.delegatorProvider = delegatorProvider;
@@ -213,6 +215,48 @@ async function makeDelegateForfeitTx(input, connectorAmount, delegatePubkey, for
     return identity.sign(tx);
 }
 async function makeSignedDelegateIntent(identity, coins, outputs, onchainOutputsIndexes, cosignerPubKeys, validAt) {
+    // 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;
+    let assetOutputIndex; // where to send the assets
+    if (assetInputs.size > 0) {
+        // 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 + BigInt(asset.amount));
+            }
+        }
+        outputAssets = [];
+        for (const [assetId, amount] of allAssets) {
+            outputAssets.push({ assetId, amount: Number(amount) });
+        }
+        const firstOffchainIndex = outputs.findIndex((_, i) => !onchainOutputsIndexes.includes(i));
+        if (firstOffchainIndex === -1) {
+            throw new Error("Cannot settle assets without an offchain output");
+        }
+        assetOutputIndex = firstOffchainIndex;
+    }
+    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,

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

@@ -1,10 +1,10 @@
 import { hex } from "@scure/base";
-import { runTasks } from '../../worker/expo/taskRunner.js';
+import { runTasks, createTaskDependencies } from '../../worker/expo/taskRunner.js';
 import { contractPollProcessor, CONTRACT_POLL_TASK_TYPE, } from '../../worker/expo/processors/index.js';
 import { DefaultVtxo } from '../../script/default.js';
 import { ExpoArkProvider } from '../../providers/expoArk.js';
 import { ExpoIndexerProvider } from '../../providers/expoIndexer.js';
-import { extendVirtualCoin, extendVtxoFromContract, getRandomId, } from '../utils.js';
+import { getRandomId } from '../utils.js';
 function requireTaskManager() {
     try {
         return require("expo-task-manager");
@@ -61,7 +61,7 @@ export function defineExpoBackgroundTask(taskName, options) {
             const arkProvider = new ExpoArkProvider(config.arkServerUrl);
             // Reconstruct default offchainTapscript as fallback
             // for VTXOs not associated with a contract.
-            const defaultTapscript = new DefaultVtxo.Script({
+            const offchainTapscript = new DefaultVtxo.Script({
                 pubKey: hex.decode(config.pubkeyHex),
                 serverPubKey: hex.decode(config.serverPubKeyHex),
                 csvTimelock: {
@@ -69,18 +69,14 @@ export function defineExpoBackgroundTask(taskName, options) {
                     type: config.exitTimelockType,
                 },
             });
-            await runTasks(taskQueue, processors, {
+            const deps = createTaskDependencies({
                 walletRepository,
                 contractRepository,
                 indexerProvider,
                 arkProvider,
-                extendVtxo: (vtxo, contract) => {
-                    if (contract) {
-                        return extendVtxoFromContract(vtxo, contract);
-                    }
-                    return extendVirtualCoin({ offchainTapscript: defaultTapscript }, vtxo);
-                },
+                offchainTapscript,
             });
+            await runTasks(taskQueue, processors, deps);
             // Acknowledge outbox results (no foreground to consume them)
             const results = await taskQueue.getResults();
             if (results.length > 0) {

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

@@ -1,4 +1,4 @@
 export { InMemoryTaskQueue } from './taskQueue.js';
 export { AsyncStorageTaskQueue } from './asyncStorageTaskQueue.js';
-export { runTasks } from './taskRunner.js';
+export { runTasks, createTaskDependencies } from './taskRunner.js';
 export { contractPollProcessor, CONTRACT_POLL_TASK_TYPE } from './processors/index.js';

package/dist/esm/worker/expo/taskRunner.js

@@ -1,4 +1,4 @@
-import { getRandomId } from '../../wallet/utils.js';
+import { getRandomId, extendVirtualCoin, extendVtxoFromContract, } from '../../wallet/utils.js';
 /**
  * Run all pending tasks from the queue through matching processors.
  *
@@ -52,3 +52,27 @@ export async function runTasks(queue, processors, deps) {
     }
     return results;
 }
+/**
+ * Build the {@link TaskDependencies} needed by task processors
+ * (e.g. {@link import("./processors").contractPollProcessor}).
+ *
+ * This is the same construction that `defineExpoBackgroundTask` does
+ * internally, extracted so that consumers with custom schedulers
+ * (e.g. bare React Native with `react-native-background-fetch`)
+ * can build deps without depending on Expo.
+ */
+export function createTaskDependencies(options) {
+    const { walletRepository, contractRepository, indexerProvider, arkProvider, offchainTapscript, } = options;
+    return {
+        walletRepository,
+        contractRepository,
+        indexerProvider,
+        arkProvider,
+        extendVtxo: (vtxo, contract) => {
+            if (contract) {
+                return extendVtxoFromContract(vtxo, contract);
+            }
+            return extendVirtualCoin({ offchainTapscript }, vtxo);
+        },
+    };
+}

package/dist/esm/worker/messageBus.js

@@ -6,7 +6,7 @@ import { ReadonlySingleKey, SingleKey } from '../identity/index.js';
 import { ReadonlyWallet, Wallet } from '../wallet/wallet.js';
 import { hex } from "@scure/base";
 export class MessageBus {
-    constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, debug = false, buildServices, }) {
+    constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, messageTimeoutMs = 30000, debug = false, buildServices, }) {
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
         this.running = false;
@@ -14,8 +14,10 @@ export class MessageBus {
         this.tickInProgress = false;
         this.debug = false;
         this.initialized = false;
+        this.boundOnMessage = this.onMessage.bind(this);
         this.handlers = new Map(messageHandlers.map((u) => [u.messageTag, u]));
         this.tickIntervalMs = tickIntervalMs;
+        this.messageTimeoutMs = messageTimeoutMs;
         this.debug = debug;
         this.buildServicesFn = buildServices ?? this.buildServices.bind(this);
     }
@@ -26,7 +28,7 @@ export class MessageBus {
         if (this.debug)
             console.log("MessageBus starting");
         // Hook message routing
-        self.addEventListener("message", this.onMessage.bind(this));
+        self.addEventListener("message", this.boundOnMessage);
         // activate service worker immediately
         self.addEventListener("install", () => {
             self.skipWaiting();
@@ -49,7 +51,7 @@ export class MessageBus {
             self.clearTimeout(this.tickTimeout);
             this.tickTimeout = null;
         }
-        self.removeEventListener("message", this.onMessage.bind(this));
+        self.removeEventListener("message", this.boundOnMessage);
         await Promise.all(Array.from(this.handlers.values()).map((updater) => updater.stop()));
     }
     scheduleNextTick() {
@@ -75,7 +77,7 @@ export class MessageBus {
             const now = Date.now();
             for (const updater of this.handlers.values()) {
                 try {
-                    const response = await updater.tick(now);
+                    const response = await this.withTimeout(updater.tick(now), `${updater.messageTag}:tick`);
                     if (this.debug)
                         console.log(`[${updater.messageTag}] outgoing tick response:`, response);
                     if (response && response.length > 0) {
@@ -166,12 +168,25 @@ export class MessageBus {
             throw new Error("Missing privateKey or publicKey in configuration object");
         }
     }
-    async onMessage(event) {
+    onMessage(event) {
+        // Keep the service worker alive while async work is pending.
+        // Without this, the browser may terminate the SW mid-operation,
+        // causing all pending responses to be lost silently.
+        const promise = this.processMessage(event);
+        if (typeof event.waitUntil === "function") {
+            event.waitUntil(promise);
+        }
+        return promise;
+    }
+    async processMessage(event) {
         const { id, tag, broadcast } = event.data;
         if (tag === "INITIALIZE_MESSAGE_BUS") {
             if (this.debug) {
                 console.log("Init Command received");
             }
+            // Intentionally not wrapped with withTimeout: initialization
+            // performs network calls (buildServices) and handler startup
+            // that may legitimately exceed the message timeout.
             await this.waitForInit(event.data.config);
             event.source?.postMessage({ id, tag });
             if (this.debug) {
@@ -205,7 +220,7 @@ export class MessageBus {
         }
         if (broadcast) {
             const updaters = Array.from(this.handlers.values());
-            const results = await Promise.allSettled(updaters.map((updater) => updater.handleMessage(event.data)));
+            const results = await Promise.allSettled(updaters.map((updater) => this.withTimeout(updater.handleMessage(event.data), updater.messageTag)));
             results.forEach((result, index) => {
                 const updater = updaters[index];
                 if (result.status === "fulfilled") {
@@ -236,7 +251,7 @@ export class MessageBus {
             return;
         }
         try {
-            const response = await updater.handleMessage(event.data);
+            const response = await this.withTimeout(updater.handleMessage(event.data), tag);
             if (this.debug)
                 console.log(`[${tag}] outgoing response:`, response);
             if (response) {
@@ -250,6 +265,27 @@ export class MessageBus {
             event.source?.postMessage({ id, tag, error });
         }
     }
+    /**
+     * Race `promise` against a timeout. Note: this does NOT cancel the
+     * underlying work — the original promise keeps running. This is safe
+     * here because only the caller (not the handler) posts the response.
+     */
+    withTimeout(promise, label) {
+        if (this.messageTimeoutMs <= 0)
+            return promise;
+        return new Promise((resolve, reject) => {
+            const timer = self.setTimeout(() => {
+                reject(new Error(`Message handler timed out after ${this.messageTimeoutMs}ms (${label})`));
+            }, this.messageTimeoutMs);
+            promise.then((val) => {
+                self.clearTimeout(timer);
+                resolve(val);
+            }, (err) => {
+                self.clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
     /**
      * Returns the registered SW for the path.
      * It uses the functions in `service-worker-manager.ts` module.

package/dist/types/worker/expo/index.d.ts

@@ -2,6 +2,6 @@ export type { TaskItem, TaskResult, TaskQueue } from "./taskQueue";
 export { InMemoryTaskQueue } from "./taskQueue";
 export type { AsyncStorageLike } from "./asyncStorageTaskQueue";
 export { AsyncStorageTaskQueue } from "./asyncStorageTaskQueue";
-export type { TaskProcessor, TaskDependencies } from "./taskRunner";
-export { runTasks } from "./taskRunner";
+export type { TaskProcessor, TaskDependencies, CreateTaskDependenciesOptions, } from "./taskRunner";
+export { runTasks, createTaskDependencies } from "./taskRunner";
 export { contractPollProcessor, CONTRACT_POLL_TASK_TYPE } from "./processors";

package/dist/types/worker/expo/taskRunner.d.ts

@@ -5,6 +5,7 @@ import type { IndexerProvider } from "../../providers/indexer";
 import type { ArkProvider } from "../../providers/ark";
 import type { ExtendedVirtualCoin, VirtualCoin } from "../../wallet";
 import type { Contract } from "../../contracts/types";
+import type { ReadonlyWallet } from "../../wallet/wallet";
 /**
  * Shared dependencies injected into every processor at runtime.
  */
@@ -40,3 +41,23 @@ export interface TaskProcessor<TDeps = TaskDependencies> {
  * Processor errors produce a `"failed"` result with the error message.
  */
 export declare function runTasks<TDeps = TaskDependencies>(queue: TaskQueue, processors: TaskProcessor<TDeps>[], deps: TDeps): Promise<TaskResult[]>;
+/**
+ * Options for {@link createTaskDependencies}.
+ */
+export interface CreateTaskDependenciesOptions {
+    walletRepository: WalletRepository;
+    contractRepository: ContractRepository;
+    indexerProvider: IndexerProvider;
+    arkProvider: ArkProvider;
+    offchainTapscript: ReadonlyWallet["offchainTapscript"];
+}
+/**
+ * Build the {@link TaskDependencies} needed by task processors
+ * (e.g. {@link import("./processors").contractPollProcessor}).
+ *
+ * This is the same construction that `defineExpoBackgroundTask` does
+ * internally, extracted so that consumers with custom schedulers
+ * (e.g. bare React Native with `react-native-background-fetch`)
+ * can build deps without depending on Expo.
+ */
+export declare function createTaskDependencies(options: CreateTaskDependenciesOptions): TaskDependencies;

package/dist/types/worker/messageBus.d.ts

@@ -48,6 +48,7 @@ export interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, R
 type Options = {
     messageHandlers: MessageHandler[];
     tickIntervalMs?: number;
+    messageTimeoutMs?: number;
     debug?: boolean;
     buildServices?: (config: Initialize["config"]) => Promise<{
         arkProvider: ArkProvider;
@@ -76,13 +77,15 @@ export declare class MessageBus {
     private readonly contractRepository;
     private handlers;
     private tickIntervalMs;
+    private messageTimeoutMs;
     private running;
     private tickTimeout;
     private tickInProgress;
     private debug;
     private initialized;
     private readonly buildServicesFn;
-    constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, debug, buildServices, }: Options);
+    private readonly boundOnMessage;
+    constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, messageTimeoutMs, debug, buildServices, }: Options);
     start(): Promise<void>;
     stop(): Promise<void>;
     private scheduleNextTick;
@@ -90,6 +93,13 @@ export declare class MessageBus {
     private waitForInit;
     private buildServices;
     private onMessage;
+    private processMessage;
+    /**
+     * Race `promise` against a timeout. Note: this does NOT cancel the
+     * underlying work — the original promise keeps running. This is safe
+     * here because only the caller (not the handler) posts the response.
+     */
+    private withTimeout;
     /**
      * Returns the registered SW for the path.
      * It uses the functions in `service-worker-manager.ts` module.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",