@arkade-os/sdk 0.4.21 → 0.4.22

package/dist/cjs/contracts/contractWatcher.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractWatcher = void 0;
-const utils_1 = require("../providers/utils");
+const utils_1 = require("../wallet/utils");
+const utils_2 = require("../providers/utils");
 /**
  * Watches multiple contracts for virtual output state changes with resilient connection handling.
  *
@@ -276,7 +277,7 @@ class ContractWatcher {
                 // indefinitely and block the caller.
                 // Error management must be implemented to ensure the connection
                 // is restored and events are fired.
-                if ((0, utils_1.isEventSourceError)(e)) {
+                if ((0, utils_2.isEventSourceError)(e)) {
                     console.debug("ContractWatcher subscription disconnected; reconnecting");
                 }
                 else {
@@ -553,18 +554,22 @@ class ContractWatcher {
         const state = this.contracts.get(contractScript);
         if (!state)
             return;
+        const extended = [];
+        for (const v of vtxos) {
+            try {
+                const extendedVtxo = (0, utils_1.extendVirtualCoinForContract)(v, state.contract);
+                extended.push({ ...extendedVtxo, contractScript });
+            }
+            catch {
+                console.warn("failed to extend vtxo: ", v);
+                extended.push({ ...v, contractScript });
+            }
+        }
         switch (eventType) {
             case "vtxo_received":
                 this.eventCallback({
                     type: "vtxo_received",
-                    vtxos: vtxos.map((v) => ({
-                        ...v,
-                        contractScript,
-                        // These fields may not be available from basic VirtualCoin
-                        forfeitTapLeafScript: undefined,
-                        intentTapLeafScript: undefined,
-                        tapTree: undefined,
-                    })),
+                    vtxos: extended,
                     contractScript,
                     contract: state.contract,
                     timestamp,
@@ -573,14 +578,7 @@ class ContractWatcher {
             case "vtxo_spent":
                 this.eventCallback({
                     type: "vtxo_spent",
-                    vtxos: vtxos.map((v) => ({
-                        ...v,
-                        contractScript,
-                        // These fields may not be available from basic VirtualCoin
-                        forfeitTapLeafScript: undefined,
-                        intentTapLeafScript: undefined,
-                        tapTree: undefined,
-                    })),
+                    vtxos: extended,
                     contractScript,
                     contract: state.contract,
                     timestamp,

package/dist/cjs/wallet/delegator.js

@@ -29,20 +29,30 @@ class DelegatorManagerImpl {
         // 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, vtxos, destinationScript, delegateAt);
+                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, eligible, destinationScript, delegateAt);
             }
             catch (error) {
-                return { delegated: [], failed: [{ outpoints: vtxos, error }] };
+                return {
+                    delegated: [],
+                    failed: [{ outpoints: eligible, error }],
+                };
             }
-            return { delegated: vtxos, failed: [] };
+            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 vtxos) {
+        for (const vtxo of eligible) {
             if ((0, __1.isRecoverable)(vtxo)) {
                 recoverableVtxos.push(vtxo);
                 continue;
@@ -190,20 +200,7 @@ async function delegate(identity, delegatorProvider, arkInfo, delegateInfo, vtxo
     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;
-    });
+    const delegateTapLeaf = findDelegateTapLeaf(input, delegatePubkey);
     if (!delegateTapLeaf) {
         throw new Error(`delegate tap leaf not found for input: ${input.txid}:${input.vout}`);
     }
@@ -291,3 +288,15 @@ function getDayTimestamp(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/serviceWorker/wallet-message-handler.js

@@ -706,7 +706,9 @@ class WalletMessageHandler {
         const { vtxoOutpoints, destination, delegateAt } = message.payload;
         const allVtxos = await wallet.getVtxos();
         const outpointSet = new Set(vtxoOutpoints.map((o) => `${o.txid}:${o.vout}`));
-        const filtered = allVtxos.filter((v) => outpointSet.has(`${v.txid}:${v.vout}`));
+        const filtered = allVtxos
+            .filter((v) => outpointSet.has(`${v.txid}:${v.vout}`))
+            .map((v) => ({ ...v, contractScript: v.script }));
         const result = await delegatorManager.delegate(filtered, destination, delegateAt !== undefined ? new Date(delegateAt) : undefined);
         return {
             tag: this.messageTag,

package/dist/cjs/wallet/vtxo-manager.js

@@ -698,11 +698,13 @@ class VtxoManager {
                         console.error("Error renewing VTXOs:", e);
                     });
                 }
-                delegatorManager
-                    ?.delegate(event.vtxos, destination)
-                    .catch((e) => {
-                    console.error("Error delegating VTXOs:", e);
-                });
+                if (delegatorManager) {
+                    delegatorManager
+                        .delegate(event.vtxos, destination)
+                        .catch((e) => {
+                        console.error("Error delegating VTXOs:", e);
+                    });
+                }
             });
             return stopWatching;
         }

package/dist/esm/contracts/contractWatcher.js

@@ -1,3 +1,4 @@
+import { extendVirtualCoinForContract } from '../wallet/utils.js';
 import { isEventSourceError } from '../providers/utils.js';
 /**
  * Watches multiple contracts for virtual output state changes with resilient connection handling.
@@ -550,18 +551,22 @@ export class ContractWatcher {
         const state = this.contracts.get(contractScript);
         if (!state)
             return;
+        const extended = [];
+        for (const v of vtxos) {
+            try {
+                const extendedVtxo = extendVirtualCoinForContract(v, state.contract);
+                extended.push({ ...extendedVtxo, contractScript });
+            }
+            catch {
+                console.warn("failed to extend vtxo: ", v);
+                extended.push({ ...v, contractScript });
+            }
+        }
         switch (eventType) {
             case "vtxo_received":
                 this.eventCallback({
                     type: "vtxo_received",
-                    vtxos: vtxos.map((v) => ({
-                        ...v,
-                        contractScript,
-                        // These fields may not be available from basic VirtualCoin
-                        forfeitTapLeafScript: undefined,
-                        intentTapLeafScript: undefined,
-                        tapTree: undefined,
-                    })),
+                    vtxos: extended,
                     contractScript,
                     contract: state.contract,
                     timestamp,
@@ -570,14 +575,7 @@ export class ContractWatcher {
             case "vtxo_spent":
                 this.eventCallback({
                     type: "vtxo_spent",
-                    vtxos: vtxos.map((v) => ({
-                        ...v,
-                        contractScript,
-                        // These fields may not be available from basic VirtualCoin
-                        forfeitTapLeafScript: undefined,
-                        intentTapLeafScript: undefined,
-                        tapTree: undefined,
-                    })),
+                    vtxos: extended,
                     contractScript,
                     contract: state.contract,
                     timestamp,

package/dist/esm/wallet/delegator.js

@@ -25,20 +25,30 @@ export class DelegatorManagerImpl {
         // 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, vtxos, destinationScript, delegateAt);
+                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, eligible, destinationScript, delegateAt);
             }
             catch (error) {
-                return { delegated: [], failed: [{ outpoints: vtxos, error }] };
+                return {
+                    delegated: [],
+                    failed: [{ outpoints: eligible, error }],
+                };
             }
-            return { delegated: vtxos, failed: [] };
+            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 vtxos) {
+        for (const vtxo of eligible) {
             if (isRecoverable(vtxo)) {
                 recoverableVtxos.push(vtxo);
                 continue;
@@ -185,20 +195,7 @@ async function delegate(identity, delegatorProvider, arkInfo, delegateInfo, vtxo
     await delegatorProvider.delegate(registerIntent, forfeits);
 }
 async function makeDelegateForfeitTx(input, connectorAmount, delegatePubkey, forfeitOutputScript, identity) {
-    if (delegatePubkey.length === 66) {
-        delegatePubkey = delegatePubkey.slice(2);
-    }
-    const vtxoScript = VtxoScript.decode(input.tapTree);
-    const delegateTapLeaf = vtxoScript.leaves.find((tapLeaf) => {
-        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
-        if (!MultisigTapscript.is(arkTapscript))
-            return false;
-        if (!arkTapscript.params.pubkeys
-            .map(hex.encode)
-            .includes(delegatePubkey))
-            return false;
-        return true;
-    });
+    const delegateTapLeaf = findDelegateTapLeaf(input, delegatePubkey);
     if (!delegateTapLeaf) {
         throw new Error(`delegate tap leaf not found for input: ${input.txid}:${input.vout}`);
     }
@@ -286,3 +283,15 @@ function getDayTimestamp(timestamp) {
     date.setUTCHours(0, 0, 0, 0);
     return date.getTime();
 }
+function findDelegateTapLeaf(vtxo, delegatePubkey) {
+    if (!vtxo.tapTree)
+        return undefined;
+    const pk = delegatePubkey.length === 66 ? delegatePubkey.slice(2) : delegatePubkey;
+    const vtxoScript = VtxoScript.decode(vtxo.tapTree);
+    return vtxoScript.leaves.find((tapLeaf) => {
+        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
+        if (!MultisigTapscript.is(arkTapscript))
+            return false;
+        return arkTapscript.params.pubkeys.map(hex.encode).includes(pk);
+    });
+}

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -700,7 +700,9 @@ export class WalletMessageHandler {
         const { vtxoOutpoints, destination, delegateAt } = message.payload;
         const allVtxos = await wallet.getVtxos();
         const outpointSet = new Set(vtxoOutpoints.map((o) => `${o.txid}:${o.vout}`));
-        const filtered = allVtxos.filter((v) => outpointSet.has(`${v.txid}:${v.vout}`));
+        const filtered = allVtxos
+            .filter((v) => outpointSet.has(`${v.txid}:${v.vout}`))
+            .map((v) => ({ ...v, contractScript: v.script }));
         const result = await delegatorManager.delegate(filtered, destination, delegateAt !== undefined ? new Date(delegateAt) : undefined);
         return {
             tag: this.messageTag,

package/dist/esm/wallet/vtxo-manager.js

@@ -693,11 +693,13 @@ export class VtxoManager {
                         console.error("Error renewing VTXOs:", e);
                     });
                 }
-                delegatorManager
-                    ?.delegate(event.vtxos, destination)
-                    .catch((e) => {
-                    console.error("Error delegating VTXOs:", e);
-                });
+                if (delegatorManager) {
+                    delegatorManager
+                        .delegate(event.vtxos, destination)
+                        .catch((e) => {
+                        console.error("Error delegating VTXOs:", e);
+                    });
+                }
             });
             return stopWatching;
         }

package/dist/types/contracts/types.d.ts

@@ -1,6 +1,6 @@
 import { Bytes } from "@scure/btc-signer/utils.js";
-import { TapLeafScript, VtxoScript } from "../script/base";
-import { VirtualCoin, ExtendedVirtualCoin } from "../wallet";
+import { EncodedVtxoScript, TapLeafScript, VtxoScript } from "../script/base";
+import { VirtualCoin, TapLeaves } from "../wallet";
 import { ContractFilter } from "../repositories";
 /**
  * Contract state indicating whether it should be actively monitored.
@@ -66,10 +66,10 @@ export interface Contract {
 /**
  * A virtual output that has been associated with a specific contract.
  */
-export interface ContractVtxo extends ExtendedVirtualCoin {
-    /** The contract script this virtual output belongs to. */
+export type ContractVtxo = VirtualCoin & Partial<TapLeaves & EncodedVtxoScript> & {
+    extraWitness?: Bytes[];
     contractScript: string;
-}
+};
 /**
  * Result of path selection, including the tapleaf to use and any extra witness data.
  */

package/dist/types/wallet/delegator.d.ts

@@ -1,17 +1,22 @@
 import { TransactionOutput } from "@scure/btc-signer/psbt";
-import { ArkProvider, DelegateInfo, ExtendedVirtualCoin, Identity, Outpoint } from "..";
+import { ArkProvider, DelegateInfo, Identity, Outpoint } from "..";
+import { ContractVtxo } from "../contracts/types";
 import { DelegatorProvider } from "../providers/delegator";
 import { Bytes } from "@scure/btc-signer/utils";
 export interface IDelegatorManager {
     /**
      * Delegate virtual outputs to the remote delegation service.
      *
+     * Vtxos that are not locked to a delegate-type contract (no tap leaf
+     * matches the delegator's pubkey) are filtered out silently, since they
+     * cannot be co-signed by the delegator.
+     *
      * @param vtxos - Virtual outputs to delegate
      * @param destination - Arkade address that should receive renewed funds
      * @param delegateAt - Optional timestamp to force a specific delegation time
      * @returns Successfully delegated and failed outpoint groups
      */
-    delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
+    delegate(vtxos: ContractVtxo[], destination: string, delegateAt?: Date): Promise<{
         delegated: Outpoint[];
         failed: {
             outpoints: Outpoint[];
@@ -28,7 +33,7 @@ export declare class DelegatorManagerImpl implements IDelegatorManager {
     /** Create a delegator manager from the configured provider, Arkade info source, and wallet identity. */
     constructor(delegatorProvider: DelegatorProvider, arkInfoProvider: Pick<ArkProvider, "getInfo">, identity: Identity);
     getDelegateInfo(): Promise<DelegateInfo>;
-    delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
+    delegate(vtxos: ContractVtxo[], destination: string, delegateAt?: Date): Promise<{
         delegated: Outpoint[];
         failed: {
             outpoints: Outpoint[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.21",
+  "version": "0.4.22",
   "description": "TypeScript SDK for building Bitcoin wallets using the Arkade protocol",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -109,9 +109,9 @@
   "peerDependencies": {
     "@react-native-async-storage/async-storage": ">=1.0.0",
     "expo": ">=54.0.0",
-    "expo-background-task": "~1.0.10",
-    "expo-sqlite": "~16.0.10",
-    "expo-task-manager": "~14.0.9"
+    "expo-background-task": "~1.0.10 || >=55.0.0",
+    "expo-sqlite": "~16.0.10 || >=55.0.0",
+    "expo-task-manager": "~14.0.9 || >=55.0.0"
   },
   "peerDependenciesMeta": {
     "expo": {