@arkade-os/sdk 0.4.0 → 0.4.1

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/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/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/package.json

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