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

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,18 +12,19 @@ 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';
-import { extendVirtualCoin } from './utils.js';
+import { extendCoin, extendVirtualCoin } from './utils.js';
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -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);
@@ -324,15 +333,12 @@ export class Wallet {
     async getBoardingUtxos() {
         const boardingAddress = await this.getBoardingAddress();
         const boardingUtxos = await this.onchainProvider.getCoins(boardingAddress);
-        const encodedBoardingTapscript = this.boardingTapscript.encode();
-        const forfeit = this.boardingTapscript.forfeit();
-        const exit = this.boardingTapscript.exit();
-        return boardingUtxos.map((utxo) => ({
-            ...utxo,
-            forfeitTapLeafScript: forfeit,
-            intentTapLeafScript: exit,
-            tapTree: encodedBoardingTapscript,
-        }));
+        const utxos = boardingUtxos.map((utxo) => {
+            return extendCoin(this, utxo);
+        });
+        // Save boardingUtxos using unified repository
+        await this.walletRepository.saveUtxos(boardingAddress, utxos);
+        return utxos;
     }
     async sendBitcoin(params) {
         if (params.amount <= 0) {
@@ -453,7 +459,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),
@@ -469,8 +475,8 @@ export class Wallet {
                 ...params.inputs.map((input) => `${input.txid}:${input.vout}`),
             ];
             const settlementStream = this.arkProvider.getEventStream(abortController.signal, topics);
-            // roundId, sweepTapTreeRoot and forfeitOutputScript are set once the BatchStarted event is received
-            let roundId;
+            // batchId, sweepTapTreeRoot and forfeitOutputScript are set once the BatchStarted event is received
+            let batchId;
             let sweepTapTreeRoot;
             const vtxoChunks = [];
             const connectorsChunks = [];
@@ -483,30 +489,26 @@ export class Wallet {
                 switch (event.type) {
                     // the settlement failed
                     case SettlementEventType.BatchFailed:
-                        // fail if the roundId is the one joined
-                        if (event.id === roundId) {
-                            throw new Error(event.reason);
-                        }
-                        break;
+                        throw new Error(event.reason);
                     case SettlementEventType.BatchStarted:
                         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;
-                            roundId = res.roundId;
+                            batchId = res.roundId;
                             if (!hasOffchainOutputs) {
                                 // if there are no offchain outputs, we don't have to handle musig2 tree signatures
                                 // we can directly advance to the finalization step
-                                step = SettlementEventType.TreeNoncesAggregated;
+                                step = SettlementEventType.TreeNonces;
                             }
                         }
                         break;
                     case SettlementEventType.TreeTx:
                         if (step !== SettlementEventType.BatchStarted &&
-                            step !== SettlementEventType.TreeNoncesAggregated) {
+                            step !== SettlementEventType.TreeNonces) {
                             continue;
                         }
                         // index 0 = vtxo tree
@@ -522,7 +524,7 @@ export class Wallet {
                         }
                         break;
                     case SettlementEventType.TreeSignature:
-                        if (step !== SettlementEventType.TreeNoncesAggregated) {
+                        if (step !== SettlementEventType.TreeNonces) {
                             continue;
                         }
                         if (!hasOffchainOutputs) {
@@ -564,7 +566,7 @@ export class Wallet {
                         break;
                     // the musig2 nonces of the vtxo tree transactions are generated
                     // the server expects now the partial musig2 signatures
-                    case SettlementEventType.TreeNoncesAggregated:
+                    case SettlementEventType.TreeNonces:
                         if (step !== SettlementEventType.TreeSigningStarted) {
                             continue;
                         }
@@ -572,14 +574,18 @@ export class Wallet {
                             if (!session) {
                                 throw new Error("Signing session not set");
                             }
-                            await this.handleSettlementSigningNoncesGeneratedEvent(event, session);
+                            const signed = await this.handleSettlementTreeNoncesEvent(event, session);
+                            if (signed) {
+                                step = event.type;
+                            }
+                            break;
                         }
                         step = event.type;
                         break;
                     // the vtxo tree is signed, craft, sign and submit forfeit transactions
                     // if any boarding utxos are involved, the settlement tx is also signed
                     case SettlementEventType.BatchFinalization:
-                        if (step !== SettlementEventType.TreeNoncesAggregated) {
+                        if (step !== SettlementEventType.TreeNonces) {
                             continue;
                         }
                         if (!this.forfeitOutputScript) {
@@ -597,8 +603,10 @@ export class Wallet {
                         if (step !== SettlementEventType.BatchFinalization) {
                             continue;
                         }
-                        abortController.abort();
-                        return event.commitmentTxid;
+                        if (event.id === batchId) {
+                            abortController.abort();
+                            return event.commitmentTxid;
+                        }
                 }
             }
         }
@@ -677,10 +685,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 +708,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 +729,19 @@ 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);
+    async handleSettlementTreeNoncesEvent(event, session) {
+        const { hasAllNonces } = await session.aggregatedNonces(event.txid, event.nonces);
+        // wait to receive and aggregate all nonces before sending signatures
+        if (!hasAllNonces)
+            return false;
+        const signatures = await session.sign();
+        const pubkey = hex.encode(await session.getPublicKey());
+        await this.arkProvider.submitTreeSignatures(event.id, pubkey, signatures);
+        return true;
     }
     async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
         // the signed forfeits transactions to submit
@@ -741,8 +756,6 @@ export class Wallet {
             const vtxo = vtxos.find((vtxo) => vtxo.txid === input.txid && vtxo.vout === input.vout);
             // boarding utxo, we need to sign the settlement tx
             if (!vtxo) {
-                hasBoardingUtxos = true;
-                const inputIndexes = [];
                 for (let i = 0; i < settlementPsbt.inputsLength; i++) {
                     const settlementInput = settlementPsbt.getInput(i);
                     if (!settlementInput.txid ||
@@ -758,9 +771,12 @@ export class Wallet {
                     settlementPsbt.updateInput(i, {
                         tapLeafScript: [input.forfeitTapLeafScript],
                     });
-                    inputIndexes.push(i);
+                    settlementPsbt = await this.identity.sign(settlementPsbt, [
+                        i,
+                    ]);
+                    hasBoardingUtxos = true;
+                    break;
                 }
-                settlementPsbt = await this.identity.sign(settlementPsbt, inputIndexes);
                 continue;
             }
             if (isRecoverable(vtxo) || isSubdust(vtxo, this.dustAmount)) {
@@ -774,7 +790,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 +831,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 "./utils/transaction";
+import { TransactionInputUpdate } from "@scure/btc-signer/psbt.js";
 export declare function buildForfeitTx(inputs: TransactionInputUpdate[], forfeitPkScript: Uint8Array, txLocktime?: number): Transaction;

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

@@ -1,10 +1,10 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
+import { Transaction } from "../utils/transaction";
 import { SignerSession } from "../tree/signingSession";
 export interface Identity {
     signerSession(): SignerSession;
     xOnlyPublicKey(): Promise<Uint8Array>;
     compressedPublicKey(): Promise<Uint8Array>;
-    signMessage(message: string): Promise<Uint8Array>;
+    signMessage(message: Uint8Array, signatureType: "schnorr" | "ecdsa"): Promise<Uint8Array>;
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
 }
 export * from "./singleKey";

package/dist/types/identity/singleKey.d.ts

@@ -1,5 +1,5 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
 import { Identity } from ".";
+import { Transaction } from "../utils/transaction";
 import { SignerSession } from "../tree/signingSession";
 /**
  * In-memory single key implementation for Bitcoin transaction signing.
@@ -35,5 +35,5 @@ export declare class SingleKey implements Identity {
     compressedPublicKey(): Promise<Uint8Array>;
     xOnlyPublicKey(): Promise<Uint8Array>;
     signerSession(): SignerSession;
-    signMessage(message: string): Promise<Uint8Array>;
+    signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
 }

package/dist/types/index.d.ts

@@ -1,15 +1,16 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
+import { Transaction } from "./utils/transaction";
 import { SingleKey } from "./identity/singleKey";
 import { Identity } from "./identity";
 import { ArkAddress } from "./script/address";
 import { VHTLC } from "./script/vhtlc";
 import { DefaultVtxo } from "./script/default";
-import { VtxoScript, EncodedVtxoScript, TapLeafScript } from "./script/base";
+import { VtxoScript, EncodedVtxoScript, TapLeafScript, TapTreeCoder } from "./script/base";
 import { TxType, IWallet, WalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, GetVtxosFilter, TapLeaves } from "./wallet";
 import { Wallet, waitForIncomingFunds, IncomingFunds } from "./wallet/wallet";
 import { TxTree, TxTreeNode } from "./tree/txTree";
 import { SignerSession, TreeNonces, TreePartialSigs } from "./tree/signingSession";
 import { Ramps } from "./wallet/ramps";
+import { VtxoManager } from "./wallet/vtxo-manager";
 import { ServiceWorkerWallet } from "./wallet/serviceWorker/wallet";
 import { OnchainWallet } from "./wallet/onchain";
 import { setupServiceWorker } from "./wallet/serviceWorker/utils";
@@ -17,11 +18,11 @@ import { Worker } from "./wallet/serviceWorker/worker";
 import { Request } from "./wallet/serviceWorker/request";
 import { Response } from "./wallet/serviceWorker/response";
 import { ESPLORA_URL, EsploraProvider, OnchainProvider, ExplorerTransaction } from "./providers/onchain";
-import { RestArkProvider, ArkProvider, SettlementEvent, SettlementEventType, ArkInfo, Intent, Output, TxNotification, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour } from "./providers/ark";
+import { RestArkProvider, ArkProvider, SettlementEvent, SettlementEventType, ArkInfo, SignedIntent, Output, TxNotification, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession } from "./providers/ark";
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType, ArkTapscript, RelativeTimelock } from "./script/tapscript";
-import { hasBoardingTxExpired, buildOffchainTx, ArkTxInput, OffchainTx } from "./utils/arkTransaction";
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, ArkTxInput, OffchainTx } from "./utils/arkTransaction";
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry } from "./utils/unknownFields";
-import { BIP322 } from "./bip322";
+import { Intent } from "./intent";
 import { ArkNote } from "./arknote";
 import { networks, Network, NetworkName } from "./networks";
 import { RestIndexerProvider, IndexerProvider, IndexerTxType, ChainTxType, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, VtxoChain, Tx, Vtxo, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent } from "./providers/indexer";
@@ -31,5 +32,6 @@ import { AnchorBumper, P2A } from "./utils/anchor";
 import { Unroll } from "./wallet/unroll";
 import { WalletRepositoryImpl } from "./repositories/walletRepository";
 import { ContractRepositoryImpl } from "./repositories/contractRepository";
-export { Wallet, SingleKey, OnchainWallet, Ramps, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, waitForIncomingFunds, hasBoardingTxExpired, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, BIP322, TxTree, P2A, Unroll, Transaction, };
-export type { Identity, IWallet, WalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, ArkInfo, Intent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };
+import { ArkError, maybeArkError } from "./providers/errors";
+export { Wallet, SingleKey, OnchainWallet, Ramps, VtxoManager, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, Intent, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, };
+export type { Identity, IWallet, WalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, ArkInfo, SignedIntent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };

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

@@ -0,0 +1,41 @@
+import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt.js";
+import { Transaction } from "../utils/transaction";
+/**
+ * Intent proof implementation for Bitcoin message signing.
+ *
+ * Intent proof defines a standard for signing Bitcoin messages as well as proving
+ * ownership of coins. This namespace provides utilities for creating and
+ * validating Intent proof.
+ *
+ * it is greatly inspired by BIP322.
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ *
+ * @example
+ * ```typescript
+ * // Create a Intent proof
+ * const proof = Intent.create(
+ *   "Hello Bitcoin!",
+ *   [input],
+ *   [output]
+ * );
+ *
+ * // Sign the proof
+ * const signedProof = await identity.sign(proof);
+ *
+ */
+export declare namespace Intent {
+    type Proof = Transaction;
+    /**
+     * Creates a new Intent proof unsigned transaction.
+     *
+     * This function constructs a special transaction that can be signed to prove
+     * ownership of VTXOs and UTXOs. The proof includes the message to be
+     * signed and the inputs/outputs that demonstrate ownership.
+     *
+     * @param message - The Intent message to be signed
+     * @param inputs - Array of transaction inputs to prove ownership of
+     * @param outputs - Optional array of transaction outputs
+     * @returns An unsigned Intent proof transaction
+     */
+    function create(message: string, inputs: TransactionInput[], outputs?: TransactionOutput[]): Proof;
+}

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

@@ -1,4 +1,4 @@
 export type { Nonces } from "./nonces";
-export { generateNonces } from "./nonces";
+export { generateNonces, aggregateNonces } from "./nonces";
 export { PartialSig, sign } from "./sign";
 export { aggregateKeys } from "./keys";

package/dist/types/musig2/nonces.d.ts

@@ -11,3 +11,4 @@ export type Nonces = {
  * Generates a pair of public and secret nonces for MuSig2 signing
  */
 export declare function generateNonces(publicKey: Uint8Array): Nonces;
+export declare function aggregateNonces(pubNonces: Uint8Array[]): Uint8Array;