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

package/dist/cjs/wallet/wallet.js

@@ -38,8 +38,8 @@ exports.waitForIncomingFunds = waitForIncomingFunds;
 const base_1 = require("@scure/base");
 const bip68 = __importStar(require("bip68"));
 const payment_js_1 = require("@scure/btc-signer/payment.js");
-const transaction_js_1 = require("@scure/btc-signer/transaction.js");
-const psbt_js_1 = require("@scure/btc-signer/psbt.js");
+const btc_signer_1 = require("@scure/btc-signer");
+const utils_js_1 = require("@scure/btc-signer/utils.js");
 const transactionHistory_1 = require("../utils/transactionHistory");
 const address_1 = require("../script/address");
 const default_1 = require("../script/default");
@@ -49,18 +49,19 @@ const ark_1 = require("../providers/ark");
 const forfeit_1 = require("../forfeit");
 const validation_1 = require("../tree/validation");
 const _1 = require(".");
-const utils_js_1 = require("@scure/btc-signer/utils.js");
 const base_2 = require("../script/base");
 const tapscript_1 = require("../script/tapscript");
 const arkTransaction_1 = require("../utils/arkTransaction");
+const vtxo_manager_1 = require("./vtxo-manager");
 const arknote_1 = require("../arknote");
-const bip322_1 = require("../bip322");
+const intent_1 = require("../intent");
 const indexer_1 = require("../providers/indexer");
 const txTree_1 = require("../tree/txTree");
+const unknownFields_1 = require("../utils/unknownFields");
 const inMemory_1 = require("../storage/inMemory");
 const walletRepository_1 = require("../repositories/walletRepository");
 const contractRepository_1 = require("../repositories/contractRepository");
-const utils_1 = require("./serviceWorker/utils");
+const utils_1 = require("./utils");
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -68,13 +69,21 @@ const utils_1 = require("./serviceWorker/utils");
  *
  * @example
  * ```typescript
- * // Create a wallet
+ * // Create a wallet with URL configuration
  * const wallet = await Wallet.create({
  *   identity: SingleKey.fromHex('your_private_key'),
  *   arkServerUrl: 'https://ark.example.com',
  *   esploraUrl: 'https://mempool.space/api'
  * });
  *
+ * // Or with custom provider instances (e.g., for Expo/React Native)
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('your_private_key'),
+ *   arkProvider: new ExpoArkProvider('https://ark.example.com'),
+ *   indexerProvider: new ExpoIndexerProvider('https://ark.example.com'),
+ *   esploraUrl: 'https://mempool.space/api'
+ * });
+ *
  * // Get addresses
  * const arkAddress = await wallet.getAddress();
  * const boardingAddress = await wallet.getBoardingAddress();
@@ -87,7 +96,7 @@ const utils_1 = require("./serviceWorker/utils");
  * ```
  */
 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;
@@ -99,20 +108,45 @@ 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,
+            ...vtxo_manager_1.DEFAULT_RENEWAL_CONFIG,
+            ...renewalConfig,
+        };
     }
     static async create(config) {
         const pubkey = await config.identity.xOnlyPublicKey();
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
-        const arkProvider = new ark_1.RestArkProvider(config.arkServerUrl);
-        const indexerProvider = new indexer_1.RestIndexerProvider(config.arkServerUrl);
+        // Use provided arkProvider instance or create a new one from arkServerUrl
+        const arkProvider = config.arkProvider ||
+            (() => {
+                if (!config.arkServerUrl) {
+                    throw new Error("Either arkProvider or arkServerUrl must be provided");
+                }
+                return new ark_1.RestArkProvider(config.arkServerUrl);
+            })();
+        // Extract arkServerUrl from provider if not explicitly provided
+        const arkServerUrl = config.arkServerUrl || arkProvider.serverUrl;
+        if (!arkServerUrl) {
+            throw new Error("Could not determine arkServerUrl from provider");
+        }
+        // Use provided indexerProvider instance or create a new one
+        // indexerUrl defaults to arkServerUrl if not provided
+        const indexerUrl = config.indexerUrl || arkServerUrl;
+        const indexerProvider = config.indexerProvider || new indexer_1.RestIndexerProvider(indexerUrl);
         const info = await arkProvider.getInfo();
         const network = (0, networks_1.getNetwork)(info.network);
-        const onchainProvider = new onchain_1.EsploraProvider(config.esploraUrl || onchain_1.ESPLORA_URL[info.network]);
+        // Extract esploraUrl from provider if not explicitly provided
+        const esploraUrl = config.esploraUrl || onchain_1.ESPLORA_URL[info.network];
+        // Use provided onchainProvider instance or create a new one
+        const onchainProvider = config.onchainProvider || new onchain_1.EsploraProvider(esploraUrl);
+        // Generate timelocks
         const exitTimelock = {
             value: info.unilateralExitDelay,
             type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
@@ -136,17 +170,24 @@ class Wallet {
         // Save tapscripts
         const offchainTapscript = bareVtxoTapscript;
         // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
-        const rawCheckpointExitClosure = base_1.hex.decode(info.checkpointExitClosure);
-        const serverUnrollScript = tapscript_1.CSVMultisigTapscript.decode(rawCheckpointExitClosure);
+        let serverUnrollScript;
+        try {
+            const raw = base_1.hex.decode(info.checkpointTapscript);
+            serverUnrollScript = tapscript_1.CSVMultisigTapscript.decode(raw);
+        }
+        catch (e) {
+            throw new Error("Invalid checkpointTapscript from server");
+        }
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
-        const forfeitAddress = (0, payment_js_1.Address)(network).decode(info.forfeitAddress);
-        const forfeitOutputScript = payment_js_1.OutScript.encode(forfeitAddress);
+        const forfeitPubkey = base_1.hex.decode(info.forfeitPubkey).slice(1);
+        const forfeitAddress = (0, btc_signer_1.Address)(network).decode(info.forfeitAddress);
+        const forfeitOutputScript = btc_signer_1.OutScript.encode(forfeitAddress);
         // Set up storage and repositories
         const storage = config.storage || new inMemory_1.InMemoryStorageAdapter();
         const walletRepository = new walletRepository_1.WalletRepositoryImpl(storage);
         const contractRepository = new contractRepository_1.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);
@@ -208,40 +249,24 @@ class Wallet {
         // if (cachedVtxos.length) return cachedVtxos;
         // For now, always fetch fresh data from provider and update cache
         // In future, we can add cache invalidation logic based on timestamps
-        const spendableVtxos = await this.getVirtualCoins(filter);
-        const encodedOffchainTapscript = this.offchainTapscript.encode();
-        const forfeit = this.offchainTapscript.forfeit();
-        const exit = this.offchainTapscript.exit();
-        const extendedVtxos = spendableVtxos.map((vtxo) => ({
-            ...vtxo,
-            forfeitTapLeafScript: forfeit,
-            intentTapLeafScript: exit,
-            tapTree: encodedOffchainTapscript,
-        }));
+        const vtxos = await this.getVirtualCoins(filter);
+        const extendedVtxos = vtxos.map((vtxo) => (0, utils_1.extendVirtualCoin)(this, vtxo));
         // Update cache with fresh data
         await this.walletRepository.saveVtxos(address, extendedVtxos);
         return extendedVtxos;
     }
     async getVirtualCoins(filter = { withRecoverable: true, withUnrolled: false }) {
         const scripts = [base_1.hex.encode(this.offchainTapscript.pkScript)];
-        const response = await this.indexerProvider.getVtxos({
-            scripts,
-            spendableOnly: true,
-        });
-        const vtxos = response.vtxos;
-        if (filter.withRecoverable) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts,
-                recoverableOnly: true,
-            });
-            vtxos.push(...response.vtxos);
+        const response = await this.indexerProvider.getVtxos({ scripts });
+        const allVtxos = response.vtxos;
+        let vtxos = allVtxos.filter(_1.isSpendable);
+        // all recoverable vtxos are spendable by definition
+        if (!filter.withRecoverable) {
+            vtxos = vtxos.filter((vtxo) => !(0, _1.isRecoverable)(vtxo));
         }
         if (filter.withUnrolled) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts,
-                spentOnly: true,
-            });
-            vtxos.push(...response.vtxos.filter((vtxo) => vtxo.isUnrolled));
+            const spentVtxos = allVtxos.filter((vtxo) => !(0, _1.isSpendable)(vtxo));
+            vtxos.push(...spentVtxos.filter((vtxo) => vtxo.isUnrolled));
         }
         return vtxos;
     }
@@ -279,10 +304,10 @@ class Wallet {
         return txs;
     }
     async getBoardingTxs() {
-        const boardingAddress = await this.getBoardingAddress();
-        const txs = await this.onchainProvider.getTransactions(boardingAddress);
         const utxos = [];
         const commitmentsToIgnore = new Set();
+        const boardingAddress = await this.getBoardingAddress();
+        const txs = await this.onchainProvider.getTransactions(boardingAddress);
         for (const tx of txs) {
             for (let i = 0; i < tx.vout.length; i++) {
                 const vout = tx.vout[i];
@@ -345,15 +370,12 @@ 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 (0, utils_1.extendCoin)(this, utxo);
+        });
+        // Save boardingUtxos using unified repository
+        await this.walletRepository.saveUtxos(boardingAddress, utxos);
+        return utxos;
     }
     async sendBitcoin(params) {
         if (params.amount <= 0) {
@@ -402,7 +424,7 @@ class Wallet {
         // TODO persist final virtual tx and checkpoints to repository
         // sign the checkpoints
         const finalCheckpoints = await Promise.all(signedCheckpointTxs.map(async (c) => {
-            const tx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(c));
+            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(c));
             const signedCheckpoint = await this.identity.sign(tx);
             return base_1.base64.encode(signedCheckpoint.toPSBT());
         }));
@@ -423,13 +445,15 @@ class Wallet {
                 }
             }
         }
-        // if no params are provided, use all boarding and offchain utxos as inputs
+        // if no params are provided, use all non expired boarding utxos and offchain vtxos as inputs
         // and send all to the offchain address
         if (!params) {
             let amount = 0;
-            const boardingUtxos = await this.getBoardingUtxos();
+            const exitScript = tapscript_1.CSVMultisigTapscript.decode(base_1.hex.decode(this.boardingTapscript.exitScript));
+            const boardingTimelock = exitScript.params.timelock;
+            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !(0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock));
             amount += boardingUtxos.reduce((sum, input) => sum + input.value, 0);
-            const vtxos = await this.getVtxos();
+            const vtxos = await this.getVtxos({ withRecoverable: true });
             amount += vtxos.reduce((sum, input) => sum + input.value, 0);
             const inputs = [...boardingUtxos, ...vtxos];
             if (inputs.length === 0) {
@@ -458,8 +482,8 @@ class Wallet {
             }
             catch {
                 // onchain
-                const addr = (0, payment_js_1.Address)(this.network).decode(output.address);
-                script = payment_js_1.OutScript.encode(addr);
+                const addr = (0, btc_signer_1.Address)(this.network).decode(output.address);
+                script = btc_signer_1.OutScript.encode(addr);
                 onchainOutputIndexes.push(index);
             }
             outputs.push({
@@ -472,7 +496,7 @@ class Wallet {
         const signingPublicKeys = [];
         if (hasOffchainOutputs) {
             session = this.identity.signerSession();
-            signingPublicKeys.push(base_1.hex.encode(session.getPublicKey()));
+            signingPublicKeys.push(base_1.hex.encode(await session.getPublicKey()));
         }
         const [intent, deleteIntent] = await Promise.all([
             this.makeRegisterIntentSignature(params.inputs, outputs, onchainOutputIndexes, signingPublicKeys),
@@ -488,8 +512,8 @@ 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 = [];
@@ -502,30 +526,26 @@ class Wallet {
                 switch (event.type) {
                     // the settlement failed
                     case ark_1.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 ark_1.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 = ark_1.SettlementEventType.TreeNoncesAggregated;
+                                step = ark_1.SettlementEventType.TreeNonces;
                             }
                         }
                         break;
                     case ark_1.SettlementEventType.TreeTx:
                         if (step !== ark_1.SettlementEventType.BatchStarted &&
-                            step !== ark_1.SettlementEventType.TreeNoncesAggregated) {
+                            step !== ark_1.SettlementEventType.TreeNonces) {
                             continue;
                         }
                         // index 0 = vtxo tree
@@ -541,7 +561,7 @@ class Wallet {
                         }
                         break;
                     case ark_1.SettlementEventType.TreeSignature:
-                        if (step !== ark_1.SettlementEventType.TreeNoncesAggregated) {
+                        if (step !== ark_1.SettlementEventType.TreeNonces) {
                             continue;
                         }
                         if (!hasOffchainOutputs) {
@@ -583,7 +603,7 @@ class Wallet {
                         break;
                     // the musig2 nonces of the vtxo tree transactions are generated
                     // the server expects now the partial musig2 signatures
-                    case ark_1.SettlementEventType.TreeNoncesAggregated:
+                    case ark_1.SettlementEventType.TreeNonces:
                         if (step !== ark_1.SettlementEventType.TreeSigningStarted) {
                             continue;
                         }
@@ -591,14 +611,18 @@ 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 ark_1.SettlementEventType.BatchFinalization:
-                        if (step !== ark_1.SettlementEventType.TreeNoncesAggregated) {
+                        if (step !== ark_1.SettlementEventType.TreeNonces) {
                             continue;
                         }
                         if (!this.forfeitOutputScript) {
@@ -616,8 +640,10 @@ class Wallet {
                         if (step !== ark_1.SettlementEventType.BatchFinalization) {
                             continue;
                         }
-                        abortController.abort();
-                        return event.commitmentTxid;
+                        if (event.id === batchId) {
+                            abortController.abort();
+                            return event.commitmentTxid;
+                        }
                 }
             }
         }
@@ -639,22 +665,22 @@ class Wallet {
         let onchainStopFunc;
         let indexerStopFunc;
         if (this.onchainProvider && boardingAddress) {
+            const findVoutOnTx = (tx) => {
+                return tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
+            };
             onchainStopFunc = await this.onchainProvider.watchAddresses([boardingAddress], (txs) => {
+                // find all utxos belonging to our boarding address
                 const coins = txs
+                    // filter txs where address is in output
+                    .filter((tx) => findVoutOnTx(tx) !== -1)
+                    // return utxo as Coin
                     .map((tx) => {
-                    const vout = tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
-                    if (vout === -1) {
-                        console.warn(`No vout found for address ${boardingAddress} in transaction ${tx.txid}`);
-                        return null;
-                    }
-                    return {
-                        txid: tx.txid,
-                        vout,
-                        value: Number(tx.vout[vout].value),
-                        status: tx.status,
-                    };
-                })
-                    .filter((coin) => coin !== null);
+                    const { txid, status } = tx;
+                    const vout = findVoutOnTx(tx);
+                    const value = Number(tx.vout[vout].value);
+                    return { txid, vout, value, status };
+                });
+                // and notify via callback
                 eventCallback({
                     type: "utxo",
                     coins,
@@ -696,10 +722,10 @@ class Wallet {
         };
         return stopFunc;
     }
-    async handleBatchStartedEvent(event, intentId, serverPubKey, forfeitOutputScript) {
+    async handleBatchStartedEvent(event, intentId, forfeitPubKey, forfeitOutputScript) {
         const utf8IntentId = new TextEncoder().encode(intentId);
         const intentIdHash = (0, utils_js_1.sha256)(utf8IntentId);
-        const intentIdHashStr = base_1.hex.encode(new Uint8Array(intentIdHash));
+        const intentIdHashStr = base_1.hex.encode(intentIdHash);
         let skip = true;
         // check if our intent ID hash matches any in the event
         for (const idHash of event.intentIdHashes) {
@@ -719,7 +745,7 @@ class Wallet {
                 value: event.batchExpiry,
                 type: event.batchExpiry >= 512n ? "seconds" : "blocks",
             },
-            pubkeys: [serverPubKey],
+            pubkeys: [forfeitPubKey],
         }).script;
         const sweepTapTreeRoot = (0, payment_js_1.tapLeafHash)(sweepTapscript);
         return {
@@ -732,7 +758,7 @@ class Wallet {
     // validates the vtxo tree, creates a signing session and generates the musig2 nonces
     async handleSettlementSigningEvent(event, sweepTapTreeRoot, session, vtxoGraph) {
         // validate the unsigned vtxo tree
-        const commitmentTx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
+        const commitmentTx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
         (0, validation_1.validateVtxoTxGraph)(vtxoGraph, commitmentTx, sweepTapTreeRoot);
         // TODO check if our registered outputs are in the vtxo tree
         const sharedOutput = commitmentTx.getOutput(0);
@@ -740,18 +766,25 @@ class Wallet {
             throw new Error("Shared output not found");
         }
         session.init(vtxoGraph, sweepTapTreeRoot, sharedOutput.amount);
-        await this.arkProvider.submitTreeNonces(event.id, base_1.hex.encode(session.getPublicKey()), session.getNonces());
+        const pubkey = base_1.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, base_1.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 = base_1.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
         const signedForfeits = [];
         const vtxos = await this.getVirtualCoins();
-        let settlementPsbt = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(event.commitmentTx));
+        let settlementPsbt = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.commitmentTx));
         let hasBoardingUtxos = false;
         let connectorIndex = 0;
         const connectorsLeaves = connectorsGraph?.leaves() || [];
@@ -760,8 +793,6 @@ 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 ||
@@ -777,9 +808,12 @@ 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 ((0, _1.isRecoverable)(vtxo) || (0, _1.isSubdust)(vtxo, this.dustAmount)) {
@@ -793,7 +827,7 @@ class Wallet {
                 throw new Error("not enough connectors received");
             }
             const connectorLeaf = connectorsLeaves[connectorIndex];
-            const connectorTxId = base_1.hex.encode((0, utils_js_1.sha256x2)(connectorLeaf.toBytes(true)).reverse());
+            const connectorTxId = connectorLeaf.id;
             const connectorOutput = connectorLeaf.getOutput(0);
             if (!connectorOutput) {
                 throw new Error("connector output not found");
@@ -812,7 +846,7 @@ class Wallet {
                         amount: BigInt(vtxo.value),
                         script: base_2.VtxoScript.decode(input.tapTree).pkScript,
                     },
-                    sighashType: transaction_js_1.SigHash.DEFAULT,
+                    sighashType: btc_signer_1.SigHash.DEFAULT,
                     tapLeafScript: [input.forfeitTapLeafScript],
                 },
                 {
@@ -834,112 +868,69 @@ 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_1.Intent.create(encodedMessage, inputs, outputs);
+        const signedProof = await this.identity.sign(proof);
         return {
-            signature,
+            proof: base_1.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_1.Intent.create(encodedMessage, inputs, []);
+        const signedProof = await this.identity.sign(proof);
         return {
-            signature,
+            proof: base_1.base64.encode(signedProof.toPSBT()),
             message: encodedMessage,
         };
     }
-    prepareBIP322Inputs(bip322Inputs) {
+    prepareIntentProofInputs(coins) {
         const inputs = [];
-        const inputTapTrees = [];
-        const inputExtraWitnesses = [];
-        for (const bip322Input of bip322Inputs) {
-            const vtxoScript = base_2.VtxoScript.decode(bip322Input.tapTree);
-            const sequence = getSequence(bip322Input);
+        for (const input of coins) {
+            const vtxoScript = base_2.VtxoScript.decode(input.tapTree);
+            const sequence = getSequence(input);
+            const unknown = [unknownFields_1.VtxoTaprootTree.encode(input.tapTree)];
+            if (input.extraWitness) {
+                unknown.push(unknownFields_1.ConditionWitness.encode(input.extraWitness));
+            }
             inputs.push({
-                txid: base_1.hex.decode(bip322Input.txid),
-                index: bip322Input.vout,
+                txid: base_1.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(base_1.hex.encode(bip322Input.tapTree));
-            inputExtraWitnesses.push(bip322Input.extraWitness || []);
         }
-        return {
-            inputs,
-            inputTapTrees,
-            finalizer: finalizeWithExtraWitnesses(inputExtraWitnesses),
-        };
-    }
-    async makeBIP322Signature(message, inputs, finalizer, outputs) {
-        const proof = bip322_1.BIP322.create(message, inputs, outputs);
-        const signedProof = await this.identity.sign(proof);
-        return bip322_1.BIP322.signature(signedProof, finalizer);
+        return inputs;
     }
 }
 exports.Wallet = Wallet;
 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,
-                            psbt_js_1.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 = tapscript_1.CSVMultisigTapscript.decode(script).params;
         sequence = bip68.encode(params.timelock.type === "blocks"

package/dist/esm/adapters/expo.js

@@ -0,0 +1,3 @@
+// Expo adapter for React Native/Expo environments
+export { ExpoArkProvider } from '../providers/expoArk.js';
+export { ExpoIndexerProvider } from '../providers/expoIndexer.js';