@arkade-os/sdk 0.3.0-alpha.8 → 0.3.1-alpha.1

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

@@ -0,0 +1,372 @@
+import { isRecoverable, isSubdust } from './index.js';
+/**
+ * Default renewal configuration values
+ */
+export const DEFAULT_RENEWAL_CONFIG = {
+    thresholdPercentage: 10,
+};
+/**
+ * Filter VTXOs that are recoverable (swept and still spendable, or preconfirmed subdust)
+ *
+ * Recovery strategy:
+ * - Always recover swept VTXOs (they've been taken by the server)
+ * - Only recover subdust preconfirmed VTXOs (to avoid locking liquidity on settled VTXOs with long expiry)
+ *
+ * @param vtxos - Array of virtual coins to check
+ * @param dustAmount - Dust threshold to identify subdust
+ * @returns Array of recoverable VTXOs
+ */
+function getRecoverableVtxos(vtxos, dustAmount) {
+    return vtxos.filter((vtxo) => {
+        // Always recover swept VTXOs
+        if (isRecoverable(vtxo)) {
+            return true;
+        }
+        // Recover preconfirmed subdust to consolidate small amounts
+        if (vtxo.virtualStatus.state === "preconfirmed" &&
+            isSubdust(vtxo, dustAmount)) {
+            return true;
+        }
+        return false;
+    });
+}
+/**
+ * Get recoverable VTXOs including subdust coins if the total value exceeds dust threshold.
+ *
+ * Decision is based on the combined total of ALL recoverable VTXOs (regular + subdust),
+ * not just the subdust portion alone.
+ *
+ * @param vtxos - Array of virtual coins to check
+ * @param dustAmount - Dust threshold amount in satoshis
+ * @returns Object containing recoverable VTXOs and whether subdust should be included
+ */
+function getRecoverableWithSubdust(vtxos, dustAmount) {
+    const recoverableVtxos = getRecoverableVtxos(vtxos, dustAmount);
+    // Separate subdust from regular recoverable
+    const subdust = [];
+    const regular = [];
+    for (const vtxo of recoverableVtxos) {
+        if (isSubdust(vtxo, dustAmount)) {
+            subdust.push(vtxo);
+        }
+        else {
+            regular.push(vtxo);
+        }
+    }
+    // Calculate totals
+    const regularTotal = regular.reduce((sum, vtxo) => sum + BigInt(vtxo.value), 0n);
+    const subdustTotal = subdust.reduce((sum, vtxo) => sum + BigInt(vtxo.value), 0n);
+    const combinedTotal = regularTotal + subdustTotal;
+    // Include subdust only if the combined total exceeds dust threshold
+    const shouldIncludeSubdust = combinedTotal >= dustAmount;
+    const vtxosToRecover = shouldIncludeSubdust ? recoverableVtxos : regular;
+    const totalAmount = vtxosToRecover.reduce((sum, vtxo) => sum + BigInt(vtxo.value), 0n);
+    return {
+        vtxosToRecover,
+        includesSubdust: shouldIncludeSubdust,
+        totalAmount,
+    };
+}
+/**
+ * Check if a VTXO is expiring soon based on threshold
+ *
+ * @param vtxo - The virtual coin to check
+ * @param thresholdMs - Threshold in milliseconds from now
+ * @returns true if VTXO expires within threshold, false otherwise
+ */
+export function isVtxoExpiringSoon(vtxo, thresholdMs) {
+    const { batchExpiry } = vtxo.virtualStatus;
+    // No expiry set means it doesn't expire
+    if (!batchExpiry) {
+        return false;
+    }
+    const now = Date.now();
+    const timeUntilExpiry = batchExpiry - now;
+    return timeUntilExpiry > 0 && timeUntilExpiry <= thresholdMs;
+}
+/**
+ * Filter VTXOs that are expiring soon
+ *
+ * @param vtxos - Array of virtual coins to check
+ * @param thresholdMs - Threshold in milliseconds from now
+ * @returns Array of VTXOs expiring within threshold
+ */
+export function getExpiringVtxos(vtxos, thresholdMs) {
+    return vtxos.filter((vtxo) => isVtxoExpiringSoon(vtxo, thresholdMs));
+}
+/**
+ * Calculate expiry threshold in milliseconds based on batch expiry and percentage
+ *
+ * @param batchExpiry - Batch expiry timestamp in milliseconds
+ * @param percentage - Percentage of total time (0-100)
+ * @returns Threshold timestamp in milliseconds from now
+ *
+ * @example
+ * // VTXO expires in 10 days, threshold is 10%
+ * const expiry = Date.now() + 10 * 24 * 60 * 60 * 1000;
+ * const threshold = calculateExpiryThreshold(expiry, 10);
+ * // Returns 1 day in milliseconds (10% of 10 days)
+ */
+export function calculateExpiryThreshold(batchExpiry, percentage) {
+    if (percentage < 0 || percentage > 100) {
+        throw new Error("Percentage must be between 0 and 100");
+    }
+    const now = Date.now();
+    const totalTime = batchExpiry - now;
+    if (totalTime <= 0) {
+        // Already expired
+        return 0;
+    }
+    // Calculate threshold as percentage of total time
+    return Math.floor((totalTime * percentage) / 100);
+}
+/**
+ * Get the minimum expiry time from a list of VTXOs
+ *
+ * @param vtxos - Array of virtual coins
+ * @returns Minimum batch expiry timestamp, or undefined if no VTXOs have expiry
+ */
+export function getMinimumExpiry(vtxos) {
+    const expiries = vtxos
+        .map((v) => v.virtualStatus.batchExpiry)
+        .filter((e) => e !== undefined);
+    if (expiries.length === 0) {
+        return undefined;
+    }
+    return Math.min(...expiries);
+}
+/**
+ * Calculate dynamic threshold based on the earliest expiring VTXO
+ *
+ * @param vtxos - Array of virtual coins
+ * @param percentage - Percentage of time until expiry (0-100)
+ * @returns Threshold in milliseconds, or undefined if no VTXOs have expiry
+ */
+export function calculateDynamicThreshold(vtxos, percentage) {
+    const minExpiry = getMinimumExpiry(vtxos);
+    if (!minExpiry) {
+        return undefined;
+    }
+    return calculateExpiryThreshold(minExpiry, percentage);
+}
+/**
+ * VtxoManager is a unified class for managing VTXO lifecycle operations including
+ * recovery of swept/expired VTXOs and renewal to prevent expiration.
+ *
+ * Key Features:
+ * - **Recovery**: Reclaim swept or expired VTXOs back to the wallet
+ * - **Renewal**: Refresh VTXO expiration time before they expire
+ * - **Smart subdust handling**: Automatically includes subdust VTXOs when economically viable
+ * - **Expiry monitoring**: Check for VTXOs that are expiring soon
+ *
+ * VTXOs become recoverable when:
+ * - The Ark server sweeps them (virtualStatus.state === "swept") and they remain spendable
+ * - They are preconfirmed subdust (to consolidate small amounts without locking liquidity on settled VTXOs)
+ *
+ * @example
+ * ```typescript
+ * // Initialize with renewal config
+ * const manager = new VtxoManager(wallet, {
+ *   enabled: true,
+ *   thresholdPercentage: 10
+ * });
+ *
+ * // Check recoverable balance
+ * const balance = await manager.getRecoverableBalance();
+ * if (balance.recoverable > 0n) {
+ *   console.log(`Can recover ${balance.recoverable} sats`);
+ *   const txid = await manager.recoverVtxos();
+ * }
+ *
+ * // Check for expiring VTXOs
+ * const expiring = await manager.getExpiringVtxos();
+ * if (expiring.length > 0) {
+ *   console.log(`${expiring.length} VTXOs expiring soon`);
+ *   const txid = await manager.renewVtxos();
+ * }
+ * ```
+ */
+export class VtxoManager {
+    constructor(wallet, renewalConfig) {
+        this.wallet = wallet;
+        this.renewalConfig = renewalConfig;
+    }
+    // ========== Recovery Methods ==========
+    /**
+     * Recover swept/expired VTXOs by settling them back to the wallet's Ark address.
+     *
+     * This method:
+     * 1. Fetches all VTXOs (including recoverable ones)
+     * 2. Filters for swept but still spendable VTXOs and preconfirmed subdust
+     * 3. Includes subdust VTXOs if the total value >= dust threshold
+     * 4. Settles everything back to the wallet's Ark address
+     *
+     * Note: Settled VTXOs with long expiry are NOT recovered to avoid locking liquidity unnecessarily.
+     * Only preconfirmed subdust is recovered to consolidate small amounts.
+     *
+     * @param eventCallback - Optional callback to receive settlement events
+     * @returns Settlement transaction ID
+     * @throws Error if no recoverable VTXOs found
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     *
+     * // Simple recovery
+     * const txid = await manager.recoverVtxos();
+     *
+     * // With event callback
+     * const txid = await manager.recoverVtxos((event) => {
+     *   console.log('Settlement event:', event.type);
+     * });
+     * ```
+     */
+    async recoverVtxos(eventCallback) {
+        // Get all VTXOs including recoverable ones
+        const allVtxos = await this.wallet.getVtxos({
+            withRecoverable: true,
+            withUnrolled: false,
+        });
+        // Get dust amount from wallet
+        const dustAmount = "dustAmount" in this.wallet
+            ? this.wallet.dustAmount
+            : 1000n;
+        // Filter recoverable VTXOs and handle subdust logic
+        const { vtxosToRecover, includesSubdust, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount);
+        if (vtxosToRecover.length === 0) {
+            throw new Error("No recoverable VTXOs found");
+        }
+        const arkAddress = await this.wallet.getAddress();
+        // Settle all recoverable VTXOs back to the wallet
+        return this.wallet.settle({
+            inputs: vtxosToRecover,
+            outputs: [
+                {
+                    address: arkAddress,
+                    amount: totalAmount,
+                },
+            ],
+        }, eventCallback);
+    }
+    /**
+     * Get information about recoverable balance without executing recovery.
+     *
+     * Useful for displaying to users before they decide to recover funds.
+     *
+     * @returns Object containing recoverable amounts and subdust information
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     * const balance = await manager.getRecoverableBalance();
+     *
+     * if (balance.recoverable > 0n) {
+     *   console.log(`You can recover ${balance.recoverable} sats`);
+     *   if (balance.includesSubdust) {
+     *     console.log(`This includes ${balance.subdust} sats from subdust VTXOs`);
+     *   }
+     * }
+     * ```
+     */
+    async getRecoverableBalance() {
+        const allVtxos = await this.wallet.getVtxos({
+            withRecoverable: true,
+            withUnrolled: false,
+        });
+        const dustAmount = "dustAmount" in this.wallet
+            ? this.wallet.dustAmount
+            : 1000n;
+        const { vtxosToRecover, includesSubdust, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount);
+        // Calculate subdust amount separately for reporting
+        const subdustAmount = vtxosToRecover
+            .filter((v) => BigInt(v.value) < dustAmount)
+            .reduce((sum, v) => sum + BigInt(v.value), 0n);
+        return {
+            recoverable: totalAmount,
+            subdust: subdustAmount,
+            includesSubdust,
+            vtxoCount: vtxosToRecover.length,
+        };
+    }
+    // ========== Renewal Methods ==========
+    /**
+     * Get VTXOs that are expiring soon based on renewal configuration
+     *
+     * @param thresholdPercentage - Optional override for threshold percentage (0-100)
+     * @returns Array of expiring VTXOs, empty array if renewal is disabled or no VTXOs expiring
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet, { enabled: true, thresholdPercentage: 10 });
+     * const expiringVtxos = await manager.getExpiringVtxos();
+     * if (expiringVtxos.length > 0) {
+     *   console.log(`${expiringVtxos.length} VTXOs expiring soon`);
+     * }
+     * ```
+     */
+    async getExpiringVtxos(thresholdPercentage) {
+        if (!this.renewalConfig?.enabled) {
+            return [];
+        }
+        const vtxos = await this.wallet.getVtxos();
+        const percentage = thresholdPercentage ??
+            this.renewalConfig.thresholdPercentage ??
+            DEFAULT_RENEWAL_CONFIG.thresholdPercentage;
+        const threshold = calculateDynamicThreshold(vtxos, percentage);
+        if (!threshold) {
+            return [];
+        }
+        return getExpiringVtxos(vtxos, threshold);
+    }
+    /**
+     * Renew VTXOs by settling them back to the wallet's address
+     *
+     * This method collects all spendable VTXOs (including recoverable ones) and settles
+     * them back to the wallet, effectively refreshing their expiration time. This is the
+     * primary way to prevent VTXOs from expiring.
+     *
+     * @param eventCallback - Optional callback for settlement events
+     * @returns Settlement transaction ID
+     * @throws Error if no VTXOs available to renew
+     * @throws Error if total amount is below dust threshold
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     *
+     * // Simple renewal
+     * const txid = await manager.renewVtxos();
+     *
+     * // With event callback
+     * const txid = await manager.renewVtxos((event) => {
+     *   console.log('Settlement event:', event.type);
+     * });
+     * ```
+     */
+    async renewVtxos(eventCallback) {
+        // Get all VTXOs (including recoverable ones)
+        const vtxos = await this.wallet.getVtxos({ withRecoverable: true });
+        if (vtxos.length === 0) {
+            throw new Error("No VTXOs available to renew");
+        }
+        const totalAmount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
+        // Get dust amount from wallet
+        const dustAmount = "dustAmount" in this.wallet
+            ? this.wallet.dustAmount
+            : 1000n;
+        // Check if total amount is above dust threshold
+        if (BigInt(totalAmount) < dustAmount) {
+            throw new Error(`Total amount ${totalAmount} is below dust threshold ${dustAmount}`);
+        }
+        const arkAddress = await this.wallet.getAddress();
+        return this.wallet.settle({
+            inputs: vtxos,
+            outputs: [
+                {
+                    address: arkAddress,
+                    amount: BigInt(totalAmount),
+                },
+            ],
+        }, eventCallback);
+    }
+}

package/dist/esm/wallet/wallet.js

@@ -1,8 +1,8 @@
 import { base64, hex } from "@scure/base";
 import * as bip68 from "bip68";
-import { Address, OutScript, tapLeafHash } from "@scure/btc-signer/payment.js";
-import { SigHash, Transaction } from "@scure/btc-signer/transaction.js";
-import { TaprootControlBlock, } from "@scure/btc-signer/psbt.js";
+import { tapLeafHash } from "@scure/btc-signer/payment.js";
+import { SigHash, Transaction, Address, OutScript, } from "@scure/btc-signer";
+import { sha256 } from "@scure/btc-signer/utils.js";
 import { vtxosToTxs } from '../utils/transactionHistory.js';
 import { ArkAddress } from '../script/address.js';
 import { DefaultVtxo } from '../script/default.js';
@@ -12,14 +12,15 @@ import { SettlementEventType, RestArkProvider, } from '../providers/ark.js';
 import { buildForfeitTx } from '../forfeit.js';
 import { validateConnectorsTxGraph, validateVtxoTxGraph, } from '../tree/validation.js';
 import { isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
-import { sha256, sha256x2 } from "@scure/btc-signer/utils.js";
 import { VtxoScript } from '../script/base.js';
 import { CSVMultisigTapscript } from '../script/tapscript.js';
 import { buildOffchainTx, hasBoardingTxExpired } from '../utils/arkTransaction.js';
+import { DEFAULT_RENEWAL_CONFIG } from './vtxo-manager.js';
 import { ArkNote } from '../arknote/index.js';
-import { BIP322 } from '../bip322/index.js';
+import { Intent } from '../intent/index.js';
 import { RestIndexerProvider } from '../providers/indexer.js';
 import { TxTree } from '../tree/txTree.js';
+import { ConditionWitness, VtxoTaprootTree } from '../utils/unknownFields.js';
 import { InMemoryStorageAdapter } from '../storage/inMemory.js';
 import { WalletRepositoryImpl, } from '../repositories/walletRepository.js';
 import { ContractRepositoryImpl, } from '../repositories/contractRepository.js';
@@ -58,7 +59,7 @@ import { extendVirtualCoin } from './utils.js';
  * ```
  */
 export class Wallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, dustAmount, walletRepository, contractRepository) {
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig) {
         this.identity = identity;
         this.network = network;
         this.networkName = networkName;
@@ -70,9 +71,15 @@ export class Wallet {
         this.boardingTapscript = boardingTapscript;
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
+        this.forfeitPubkey = forfeitPubkey;
         this.dustAmount = dustAmount;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
+        this.renewalConfig = {
+            enabled: renewalConfig?.enabled ?? false,
+            ...DEFAULT_RENEWAL_CONFIG,
+            ...renewalConfig,
+        };
     }
     static async create(config) {
         const pubkey = await config.identity.xOnlyPublicKey();
@@ -102,6 +109,7 @@ export class Wallet {
         const esploraUrl = config.esploraUrl || ESPLORA_URL[info.network];
         // Use provided onchainProvider instance or create a new one
         const onchainProvider = config.onchainProvider || new EsploraProvider(esploraUrl);
+        // Generate timelocks
         const exitTimelock = {
             value: info.unilateralExitDelay,
             type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
@@ -127,21 +135,22 @@ export class Wallet {
         // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
         let serverUnrollScript;
         try {
-            const raw = hex.decode(info.checkpointExitClosure);
+            const raw = hex.decode(info.checkpointTapscript);
             serverUnrollScript = CSVMultisigTapscript.decode(raw);
         }
         catch (e) {
-            throw new Error("Invalid checkpointExitClosure from server");
+            throw new Error("Invalid checkpointTapscript from server");
         }
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
+        const forfeitPubkey = hex.decode(info.forfeitPubkey).slice(1);
         const forfeitAddress = Address(network).decode(info.forfeitAddress);
         const forfeitOutputScript = OutScript.encode(forfeitAddress);
         // Set up storage and repositories
         const storage = config.storage || new InMemoryStorageAdapter();
         const walletRepository = new WalletRepositoryImpl(storage);
         const contractRepository = new ContractRepositoryImpl(storage);
-        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, info.dust, walletRepository, contractRepository);
+        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, info.dust, walletRepository, contractRepository, config.renewalConfig);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
@@ -453,7 +462,7 @@ export class Wallet {
         const signingPublicKeys = [];
         if (hasOffchainOutputs) {
             session = this.identity.signerSession();
-            signingPublicKeys.push(hex.encode(session.getPublicKey()));
+            signingPublicKeys.push(hex.encode(await session.getPublicKey()));
         }
         const [intent, deleteIntent] = await Promise.all([
             this.makeRegisterIntentSignature(params.inputs, outputs, onchainOutputIndexes, signingPublicKeys),
@@ -492,7 +501,7 @@ export class Wallet {
                         if (step !== undefined) {
                             continue;
                         }
-                        const res = await this.handleBatchStartedEvent(event, intentId, this.arkServerPublicKey, this.forfeitOutputScript);
+                        const res = await this.handleBatchStartedEvent(event, intentId, this.forfeitPubkey, this.forfeitOutputScript);
                         if (!res.skip) {
                             step = event.type;
                             sweepTapTreeRoot = res.sweepTapTreeRoot;
@@ -677,10 +686,10 @@ export class Wallet {
         };
         return stopFunc;
     }
-    async handleBatchStartedEvent(event, intentId, serverPubKey, forfeitOutputScript) {
+    async handleBatchStartedEvent(event, intentId, forfeitPubKey, forfeitOutputScript) {
         const utf8IntentId = new TextEncoder().encode(intentId);
         const intentIdHash = sha256(utf8IntentId);
-        const intentIdHashStr = hex.encode(new Uint8Array(intentIdHash));
+        const intentIdHashStr = hex.encode(intentIdHash);
         let skip = true;
         // check if our intent ID hash matches any in the event
         for (const idHash of event.intentIdHashes) {
@@ -700,7 +709,7 @@ export class Wallet {
                 value: event.batchExpiry,
                 type: event.batchExpiry >= 512n ? "seconds" : "blocks",
             },
-            pubkeys: [serverPubKey],
+            pubkeys: [forfeitPubKey],
         }).script;
         const sweepTapTreeRoot = tapLeafHash(sweepTapscript);
         return {
@@ -721,12 +730,15 @@ export class Wallet {
             throw new Error("Shared output not found");
         }
         session.init(vtxoGraph, sweepTapTreeRoot, sharedOutput.amount);
-        await this.arkProvider.submitTreeNonces(event.id, hex.encode(session.getPublicKey()), session.getNonces());
+        const pubkey = hex.encode(await session.getPublicKey());
+        const nonces = await session.getNonces();
+        await this.arkProvider.submitTreeNonces(event.id, pubkey, nonces);
     }
     async handleSettlementSigningNoncesGeneratedEvent(event, session) {
         session.setAggregatedNonces(event.treeNonces);
-        const signatures = session.sign();
-        await this.arkProvider.submitTreeSignatures(event.id, hex.encode(session.getPublicKey()), signatures);
+        const signatures = await session.sign();
+        const pubkey = hex.encode(await session.getPublicKey());
+        await this.arkProvider.submitTreeSignatures(event.id, pubkey, signatures);
     }
     async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
         // the signed forfeits transactions to submit
@@ -774,7 +786,7 @@ export class Wallet {
                 throw new Error("not enough connectors received");
             }
             const connectorLeaf = connectorsLeaves[connectorIndex];
-            const connectorTxId = hex.encode(sha256x2(connectorLeaf.toBytes(true)).reverse());
+            const connectorTxId = connectorLeaf.id;
             const connectorOutput = connectorLeaf.getOutput(0);
             if (!connectorOutput) {
                 throw new Error("connector output not found");
@@ -815,111 +827,68 @@ export class Wallet {
                 : undefined);
         }
     }
-    async makeRegisterIntentSignature(bip322Inputs, outputs, onchainOutputsIndexes, cosignerPubKeys) {
+    async makeRegisterIntentSignature(coins, outputs, onchainOutputsIndexes, cosignerPubKeys) {
         const nowSeconds = Math.floor(Date.now() / 1000);
-        const { inputs, inputTapTrees, finalizer } = this.prepareBIP322Inputs(bip322Inputs);
+        const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "register",
-            input_tap_trees: inputTapTrees,
             onchain_output_indexes: onchainOutputsIndexes,
             valid_at: nowSeconds,
             expire_at: nowSeconds + 2 * 60, // valid for 2 minutes
             cosigners_public_keys: cosignerPubKeys,
         };
         const encodedMessage = JSON.stringify(message, null, 0);
-        const signature = await this.makeBIP322Signature(encodedMessage, inputs, finalizer, outputs);
+        const proof = Intent.create(encodedMessage, inputs, outputs);
+        const signedProof = await this.identity.sign(proof);
         return {
-            signature,
+            proof: base64.encode(signedProof.toPSBT()),
             message: encodedMessage,
         };
     }
-    async makeDeleteIntentSignature(bip322Inputs) {
+    async makeDeleteIntentSignature(coins) {
         const nowSeconds = Math.floor(Date.now() / 1000);
-        const { inputs, finalizer } = this.prepareBIP322Inputs(bip322Inputs);
+        const inputs = this.prepareIntentProofInputs(coins);
         const message = {
             type: "delete",
             expire_at: nowSeconds + 2 * 60, // valid for 2 minutes
         };
         const encodedMessage = JSON.stringify(message, null, 0);
-        const signature = await this.makeBIP322Signature(encodedMessage, inputs, finalizer);
+        const proof = Intent.create(encodedMessage, inputs, []);
+        const signedProof = await this.identity.sign(proof);
         return {
-            signature,
+            proof: base64.encode(signedProof.toPSBT()),
             message: encodedMessage,
         };
     }
-    prepareBIP322Inputs(bip322Inputs) {
+    prepareIntentProofInputs(coins) {
         const inputs = [];
-        const inputTapTrees = [];
-        const inputExtraWitnesses = [];
-        for (const bip322Input of bip322Inputs) {
-            const vtxoScript = VtxoScript.decode(bip322Input.tapTree);
-            const sequence = getSequence(bip322Input);
+        for (const input of coins) {
+            const vtxoScript = VtxoScript.decode(input.tapTree);
+            const sequence = getSequence(input);
+            const unknown = [VtxoTaprootTree.encode(input.tapTree)];
+            if (input.extraWitness) {
+                unknown.push(ConditionWitness.encode(input.extraWitness));
+            }
             inputs.push({
-                txid: hex.decode(bip322Input.txid),
-                index: bip322Input.vout,
+                txid: hex.decode(input.txid),
+                index: input.vout,
                 witnessUtxo: {
-                    amount: BigInt(bip322Input.value),
+                    amount: BigInt(input.value),
                     script: vtxoScript.pkScript,
                 },
                 sequence,
-                tapLeafScript: [bip322Input.intentTapLeafScript],
+                tapLeafScript: [input.intentTapLeafScript],
+                unknown,
             });
-            inputTapTrees.push(hex.encode(bip322Input.tapTree));
-            inputExtraWitnesses.push(bip322Input.extraWitness || []);
         }
-        return {
-            inputs,
-            inputTapTrees,
-            finalizer: finalizeWithExtraWitnesses(inputExtraWitnesses),
-        };
-    }
-    async makeBIP322Signature(message, inputs, finalizer, outputs) {
-        const proof = BIP322.create(message, inputs, outputs);
-        const signedProof = await this.identity.sign(proof);
-        return BIP322.signature(signedProof, finalizer);
+        return inputs;
     }
 }
 Wallet.MIN_FEE_RATE = 1; // sats/vbyte
-function finalizeWithExtraWitnesses(inputExtraWitnesses) {
-    return function (tx) {
-        for (let i = 0; i < tx.inputsLength; i++) {
-            try {
-                tx.finalizeIdx(i);
-            }
-            catch (e) {
-                // handle empty witness error
-                if (e instanceof Error &&
-                    e.message.includes("finalize/taproot: empty witness")) {
-                    const tapLeaves = tx.getInput(i).tapLeafScript;
-                    if (!tapLeaves || tapLeaves.length <= 0)
-                        throw e;
-                    const [cb, s] = tapLeaves[0];
-                    const script = s.slice(0, -1);
-                    tx.updateInput(i, {
-                        finalScriptWitness: [
-                            script,
-                            TaprootControlBlock.encode(cb),
-                        ],
-                    });
-                }
-            }
-            const finalScriptWitness = tx.getInput(i).finalScriptWitness;
-            if (!finalScriptWitness)
-                throw new Error("input not finalized");
-            // input 0 and 1 spend the same pkscript
-            const extra = inputExtraWitnesses[i === 0 ? 0 : i - 1];
-            if (extra && extra.length > 0) {
-                tx.updateInput(i, {
-                    finalScriptWitness: [...extra, ...finalScriptWitness],
-                });
-            }
-        }
-    };
-}
-function getSequence(bip322Input) {
+function getSequence(coin) {
     let sequence = undefined;
     try {
-        const scriptWithLeafVersion = bip322Input.intentTapLeafScript[1];
+        const scriptWithLeafVersion = coin.intentTapLeafScript[1];
         const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
         const params = CSVMultisigTapscript.decode(script).params;
         sequence = bip68.encode(params.timelock.type === "blocks"

package/dist/types/arknote/index.d.ts

@@ -1,5 +1,5 @@
-import { TapLeafScript, VtxoScript } from "../script/base";
 import { Bytes } from "@scure/btc-signer/utils.js";
+import { TapLeafScript, VtxoScript } from "../script/base";
 import { ExtendedCoin, Status } from "../wallet";
 /**
  * ArkNotes are special virtual coins in the Ark protocol that can be created

package/dist/types/forfeit.d.ts

@@ -1,3 +1,3 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-import { TransactionInputUpdate } from "@scure/btc-signer/psbt";
+import { Transaction } from "@scure/btc-signer";
+import { TransactionInputUpdate } from "@scure/btc-signer/psbt.js";
 export declare function buildForfeitTx(inputs: TransactionInputUpdate[], forfeitPkScript: Uint8Array, txLocktime?: number): Transaction;