@arkade-os/sdk 0.4.31 → 0.4.33

package/dist/{chunk-HJM6JPG4.js → chunk-DSS2GQUG.js}

@@ -1,5 +1,5 @@
-import { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-6NWNOLL3.js';
-import { isMainnetDescriptor, descriptorIsOurs, contractHandlers, DelegateVtxo, DefaultVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey } from './chunk-YA4G7RFB.js';
+import { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-E22HEKLN.js';
+import { isMainnetDescriptor, descriptorIsOurs, contractHandlers, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, BoardingContractHandler } from './chunk-AOJUURHM.js';
 import { VtxoScript, timelockToSequence, DEFAULT_NETWORK, DEFAULT_NETWORK_NAME, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, ArkAddress, getSequence, CSVMultisigTapscript, getNetwork, MultisigTapscript, networks as networks$1, DEFAULT_ARKADE_SERVER_URL } from './chunk-TU3LVAPX.js';
 import { sha256, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr, equalBytes as equalBytes$1 } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, p2tr, RawWitness, Address, OutScript, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
@@ -1966,12 +1966,22 @@ function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubke
   }
 }
 function combineTapscriptSigs(signedTx, originalTx) {
+  if (signedTx.inputsLength !== originalTx.inputsLength) {
+    throw new Error(
+      `combineTapscriptSigs: input count mismatch (signedTx ${signedTx.inputsLength}, originalTx ${originalTx.inputsLength})`
+    );
+  }
   for (let i = 0; i < signedTx.inputsLength; i++) {
     const input = originalTx.getInput(i);
     const signedInput = signedTx.getInput(i);
-    if (!input.tapScriptSig) throw new Error("No tapScriptSig");
+    if (!input.tapScriptSig) {
+      throw new Error(`combineTapscriptSigs: originalTx input ${i} has no tapScriptSig`);
+    }
+    if (!signedInput.tapScriptSig) {
+      throw new Error(`combineTapscriptSigs: signedTx input ${i} has no tapScriptSig`);
+    }
     originalTx.updateInput(i, {
-      tapScriptSig: input.tapScriptSig?.concat(signedInput.tapScriptSig)
+      tapScriptSig: input.tapScriptSig.concat(signedInput.tapScriptSig)
     });
   }
   return originalTx;
@@ -3657,6 +3667,15 @@ var txKey = {
   boardingTxid: "",
   arkTxid: ""
 };
+function consumeBoardingReceive(boardingTxs, predicate) {
+  const index = boardingTxs.findIndex(predicate);
+  if (index === -1) return false;
+  boardingTxs.splice(index, 1);
+  return true;
+}
+function isSettledBoardingReceive(tx) {
+  return tx.type === "RECEIVED" /* TxReceived */ && tx.settled && tx.key.boardingTxid !== "";
+}
 function collectAssets(vtxos) {
   const map = /* @__PURE__ */ new Map();
   for (const vtxo of vtxos) {
@@ -3696,24 +3715,39 @@ function subtractAssets(spent, change) {
 }
 async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore, getTxCreatedAt) {
   const fromOldestVtxo = [...vtxos].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  const unmatchedSettledBoardingTxs = allBoardingTxs.filter(isSettledBoardingReceive).sort((a, b) => a.createdAt - b.createdAt);
   const sent = [];
   let received = [];
   for (const vtxo of fromOldestVtxo) {
     if (vtxo.status.isLeaf) {
-      if (!commitmentsToIgnore.has(vtxo.virtualStatus.commitmentTxIds[0]) && fromOldestVtxo.filter((v) => v.settledBy === vtxo.virtualStatus.commitmentTxIds[0]).length === 0) {
-        const assets = collectAssets([vtxo]);
-        received.push({
-          key: {
-            ...txKey,
-            commitmentTxid: vtxo.virtualStatus.commitmentTxIds[0]
-          },
-          tag: "batch",
-          type: "RECEIVED" /* TxReceived */,
-          amount: vtxo.value,
-          settled: vtxo.status.isLeaf || vtxo.isSpent,
-          createdAt: vtxo.createdAt.getTime(),
-          ...assets && { assets }
-        });
+      const commitmentTxid = vtxo.virtualStatus.commitmentTxIds[0];
+      const vtxoCreatedAt = vtxo.createdAt.getTime();
+      const ignoredCommitment = commitmentsToIgnore.has(commitmentTxid) || !!vtxo.settledBy && commitmentsToIgnore.has(vtxo.settledBy);
+      if (ignoredCommitment) {
+        consumeBoardingReceive(
+          unmatchedSettledBoardingTxs,
+          (tx) => tx.createdAt <= vtxoCreatedAt && (tx.key.commitmentTxid === commitmentTxid || tx.key.commitmentTxid === vtxo.settledBy)
+        );
+      } else if (fromOldestVtxo.filter((v) => v.settledBy === vtxo.virtualStatus.commitmentTxIds[0]).length === 0) {
+        const duplicateBoardingReceive = consumeBoardingReceive(
+          unmatchedSettledBoardingTxs,
+          (tx) => tx.amount === vtxo.value && tx.createdAt <= vtxoCreatedAt
+        );
+        if (!duplicateBoardingReceive) {
+          const assets = collectAssets([vtxo]);
+          received.push({
+            key: {
+              ...txKey,
+              commitmentTxid
+            },
+            tag: "batch",
+            type: "RECEIVED" /* TxReceived */,
+            amount: vtxo.value,
+            settled: vtxo.status.isLeaf || vtxo.isSpent,
+            createdAt: vtxoCreatedAt,
+            ...assets && { assets }
+          });
+        }
       }
     } else if (fromOldestVtxo.filter((v) => v.arkTxId === vtxo.txid).length === 0) {
       const assets = collectAssets([vtxo]);
@@ -7535,7 +7569,7 @@ var WalletReceiveRotator = class _WalletReceiveRotator {
     const newScript = hex.encode(newTapscript.pkScript);
     const newAddress = newTapscript.address(wallet.network.hrp, wallet.arkServerPublicKey).encode();
     const manager = await wallet.getContractManager();
-    const csvTimelock = newTapscript.options.csvTimelock ?? DefaultVtxo.Script.DEFAULT_TIMELOCK;
+    const csvTimelock = newTapscript.options.csvTimelock;
     const csvTimelockStr = timelockToSequence(csvTimelock).toString();
     const serverPubKeyHex = hex.encode(newTapscript.options.serverPubKey);
     const baseParams = {
@@ -7668,8 +7702,24 @@ var InputSignerRouter = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async sign(tx, jobs) {
-    if (jobs.length === 0) return tx;
+  /**
+   * Resolve each job to its target signer without invoking signing. The
+   * returned plan is the single source of truth for both {@link sign} and
+   * the batch-eligibility predicate {@link canBatch} — callers that want
+   * to pre-flight a batch path call {@link canBatch} (which delegates
+   * here) so the routing rules never live in two places.
+   *
+   * Throws {@link MissingSigningDescriptorError} for a non-baseline
+   * default/delegate contract whose `metadata.signingDescriptor` is
+   * missing — the same condition that would later abort signing. Failing
+   * here moves the failure earlier, before any PSBT is mutated.
+   */
+  async classify(jobs) {
+    const identityIndexes = [];
+    const descriptorGroups = /* @__PURE__ */ new Map();
+    if (jobs.length === 0) {
+      return { identityIndexes, descriptorGroups };
+    }
     const distinctScripts = Array.from(new Set(jobs.map((j) => hex.encode(j.lookupScript))));
     const contracts = await this.deps.contractRepository.getContracts({
       script: distinctScripts
@@ -7682,8 +7732,6 @@ var InputSignerRouter = class {
     }
     const baselinePubKeyHex = hex.encode(await this.deps.identity.xOnlyPublicKey());
     const boardingScriptHex = hex.encode(this.deps.boardingPkScript);
-    const identityIndexes = [];
-    const descriptorGroups = /* @__PURE__ */ new Map();
     for (const job of jobs) {
       const scriptHex = hex.encode(job.lookupScript);
       const contract = scriptToContract.get(scriptHex);
@@ -7716,6 +7764,31 @@ var InputSignerRouter = class {
         descriptorGroups.set(descriptor, [job.index]);
       }
     }
+    return { identityIndexes, descriptorGroups };
+  }
+  /**
+   * Returns `true` when every signable input across all `jobSets` resolves
+   * to the baseline {@link Identity} key — i.e. the descriptor provider
+   * would not be invoked. Used by the wallet's send/recovery paths to
+   * pre-flight the {@link BatchSignableIdentity.signMultiple} fast path,
+   * which can only fold work a single identity key can sign.
+   *
+   * Accepts several job sets (e.g. an arkTx's jobs plus one set per
+   * checkpoint) and classifies their union in a single pass. Eligibility
+   * is monotonic — the union routes entirely to the baseline key iff every
+   * set does — so this returns the same answer as ANDing the per-set
+   * results, but with one {@link classify} (one repo round-trip + one
+   * `xOnlyPublicKey` call) instead of one per set. Only the routing buckets
+   * matter here, so the input-index collisions produced by flattening jobs
+   * from different transactions are irrelevant.
+   */
+  async canBatch(...jobSets) {
+    const plan = await this.classify(jobSets.flat());
+    return plan.descriptorGroups.size === 0;
+  }
+  async sign(tx, jobs) {
+    if (jobs.length === 0) return tx;
+    const { identityIndexes, descriptorGroups } = await this.classify(jobs);
     let signed = tx;
     if (identityIndexes.length > 0) {
       signed = await this.deps.identity.sign(signed, identityIndexes);
@@ -7773,6 +7846,20 @@ function dedupeTimelocks(timelocks) {
   }
   return deduped;
 }
+function areSameScriptBaselineTypesCompatible(existingType, requestedType) {
+  if (existingType === requestedType) return true;
+  return existingType === "default" && requestedType === "boarding" || existingType === "boarding" && requestedType === "default";
+}
+async function ensureWalletContract(manager, params) {
+  const [existing] = await manager.getContracts({ script: params.script });
+  if (existing && existing.type !== params.type && areSameScriptBaselineTypesCompatible(existing.type, params.type)) {
+    if (params.type === "default" && existing.type === "boarding") {
+      await manager.updateContract(params.script, { type: "default" });
+    }
+    return;
+  }
+  await manager.createContract(params);
+}
 function hasToReadonly(identity) {
   return typeof identity === "object" && identity !== null && "toReadonly" in identity && typeof identity.toReadonly === "function";
 }
@@ -7801,9 +7888,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     this._offchainTapscript = offchainTapscript;
     this.watcherConfig = watcherConfig;
     this._assetManager = new ReadonlyAssetManager(this.indexerProvider);
-    this.walletContractTimelocks = walletContractTimelocks && walletContractTimelocks.length > 0 ? dedupeTimelocks(walletContractTimelocks) : [
-      this.offchainTapscript.options.csvTimelock ?? DefaultVtxo.Script.DEFAULT_TIMELOCK
-    ];
+    this.walletContractTimelocks = walletContractTimelocks && walletContractTimelocks.length > 0 ? dedupeTimelocks(walletContractTimelocks) : [this.offchainTapscript.options.csvTimelock];
   }
   _contractManager;
   _contractManagerInitializing;
@@ -7909,9 +7994,10 @@ var ReadonlyWallet = class _ReadonlyWallet {
       csvTimelock: exitTimelock
     };
     const offchainTapscript = !delegatePubKey ? new DefaultVtxo.Script(offchainOptions) : new DelegateVtxo.Script({ ...offchainOptions, delegatePubKey });
-    const boardingTapscript = new DefaultVtxo.Script({
-      ...offchainOptions,
-      csvTimelock: boardingTimelock
+    const boardingTapscript = BoardingContractHandler.createScript({
+      pubKey: hex.encode(pubKey),
+      serverPubKey: hex.encode(serverPubKey),
+      csvTimelock: timelockToSequence(boardingTimelock).toString()
     });
     const walletRepository = config.storage?.walletRepository ?? new IndexedDBWalletRepository();
     const contractRepository = config.storage?.contractRepository ?? new IndexedDBContractRepository();
@@ -8120,7 +8206,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       const tx = {
         key: {
           boardingTxid: utxo.txid,
-          commitmentTxid: "",
+          commitmentTxid: utxo.virtualStatus.commitmentTxIds?.[0] ?? "",
           arkTxid: ""
         },
         amount: utxo.value,
@@ -8324,7 +8410,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
         csvTimelock
       });
       const defaultScriptHex = hex.encode(defaultScript.pkScript);
-      await manager.createContract({
+      await ensureWalletContract(manager, {
         type: "default",
         params: {
           pubKey: hex.encode(defaultScript.options.pubKey),
@@ -8357,6 +8443,19 @@ var ReadonlyWallet = class _ReadonlyWallet {
         });
       }
     }
+    const boardingScriptHex = hex.encode(this.boardingTapscript.pkScript);
+    const boardingCsvTimelock = this.boardingTapscript.options.csvTimelock ?? DefaultVtxo.Script.DEFAULT_TIMELOCK;
+    await ensureWalletContract(manager, {
+      type: "boarding",
+      params: {
+        pubKey: hex.encode(this.boardingTapscript.options.pubKey),
+        serverPubKey: hex.encode(this.boardingTapscript.options.serverPubKey),
+        csvTimelock: timelockToSequence(boardingCsvTimelock).toString()
+      },
+      script: boardingScriptHex,
+      address: this.boardingTapscript.address(this.network.hrp, this.arkServerPublicKey).encode(),
+      state: "active"
+    });
     return manager;
   }
   /** Dispose wallet-owned managers and release background resources. */
@@ -9306,16 +9405,38 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           seen.add(pendingTx.arkTxid);
           batchPending.push(pendingTx.arkTxid);
           try {
-            const finalCheckpoints = await Promise.all(
-              pendingTx.signedCheckpointTxs.map(async (c) => {
-                const tx = Transaction$2.fromPSBT(base64.decode(c));
-                const signedCheckpoint = await this._signerRouter.sign(
-                  tx,
-                  this.inputSigningJobsFromWitnessUtxos(tx)
-                );
-                return base64.encode(signedCheckpoint.toPSBT());
-              })
+            const checkpointTxs = pendingTx.signedCheckpointTxs.map(
+              (c) => Transaction$2.fromPSBT(base64.decode(c))
+            );
+            const checkpointJobs = checkpointTxs.map(
+              (tx) => this.inputSigningJobsFromWitnessUtxos(tx)
             );
+            const identity = this.identity;
+            const batchEligible = isBatchSignable(identity) && await this._signerRouter.canBatch(...checkpointJobs);
+            let finalCheckpoints;
+            if (batchEligible) {
+              const requests = checkpointTxs.map((tx, i) => ({
+                tx,
+                inputIndexes: checkpointJobs[i].map((j) => j.index)
+              }));
+              const signed = await identity.signMultiple(requests);
+              if (signed.length !== requests.length) {
+                throw new Error(
+                  `signMultiple returned ${signed.length} transactions, expected ${requests.length}`
+                );
+              }
+              finalCheckpoints = signed.map((tx) => base64.encode(tx.toPSBT()));
+            } else {
+              finalCheckpoints = await Promise.all(
+                checkpointTxs.map(async (tx, i) => {
+                  const signedCheckpoint = await this._signerRouter.sign(
+                    tx,
+                    checkpointJobs[i]
+                  );
+                  return base64.encode(signedCheckpoint.toPSBT());
+                })
+              );
+            }
             await this.arkProvider.finalizeTx(pendingTx.arkTxid, finalCheckpoints);
             batchFinalized.push(pendingTx.arkTxid);
           } catch (error) {
@@ -9543,22 +9664,65 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       index,
       lookupScript: VtxoScript.decode(input.tapTree).pkScript
     }));
-    const signedVirtualTx = await this._signerRouter.sign(offchainTx.arkTx, arkTxJobs);
+    const checkpointJobs = offchainTx.checkpoints.map(
+      (c) => this.inputSigningJobsFromWitnessUtxos(c)
+    );
+    let signedVirtualTx;
+    let userSignedCheckpoints;
+    const identity = this.identity;
+    const batchEligible = isBatchSignable(identity) && await this._signerRouter.canBatch(arkTxJobs, ...checkpointJobs);
+    if (batchEligible) {
+      const requests = [
+        {
+          tx: offchainTx.arkTx.clone(),
+          inputIndexes: arkTxJobs.map((j) => j.index)
+        },
+        ...offchainTx.checkpoints.map((c, i) => ({
+          tx: c.clone(),
+          inputIndexes: checkpointJobs[i].map((j) => j.index)
+        }))
+      ];
+      const signed = await identity.signMultiple(requests);
+      if (signed.length !== requests.length) {
+        throw new Error(
+          `signMultiple returned ${signed.length} transactions, expected ${requests.length}`
+        );
+      }
+      const [firstSignedTx, ...signedCheckpoints] = signed;
+      signedVirtualTx = firstSignedTx;
+      userSignedCheckpoints = signedCheckpoints;
+    } else {
+      signedVirtualTx = await this._signerRouter.sign(offchainTx.arkTx, arkTxJobs);
+    }
     await this.setPendingTxFlag(true);
     const { arkTxid, signedCheckpointTxs } = await this.arkProvider.submitTx(
       base64.encode(signedVirtualTx.toPSBT()),
       offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT()))
     );
-    const finalCheckpoints = await Promise.all(
-      signedCheckpointTxs.map(async (c) => {
-        const tx = Transaction$2.fromPSBT(base64.decode(c));
-        const signedCheckpoint = await this._signerRouter.sign(
-          tx,
-          this.inputSigningJobsFromWitnessUtxos(tx)
+    let finalCheckpoints;
+    if (userSignedCheckpoints) {
+      if (signedCheckpointTxs.length !== userSignedCheckpoints.length) {
+        throw new Error(
+          `submitTx returned ${signedCheckpointTxs.length} checkpoints, expected ${userSignedCheckpoints.length}`
         );
-        return base64.encode(signedCheckpoint.toPSBT());
-      })
-    );
+      }
+      finalCheckpoints = signedCheckpointTxs.map((c, i) => {
+        const serverSigned = Transaction$2.fromPSBT(base64.decode(c));
+        combineTapscriptSigs(userSignedCheckpoints[i], serverSigned);
+        return base64.encode(serverSigned.toPSBT());
+      });
+    } else {
+      finalCheckpoints = await Promise.all(
+        signedCheckpointTxs.map(async (c) => {
+          const tx = Transaction$2.fromPSBT(base64.decode(c));
+          const signedCheckpoint = await this._signerRouter.sign(
+            tx,
+            this.inputSigningJobsFromWitnessUtxos(tx)
+          );
+          return base64.encode(signedCheckpoint.toPSBT());
+        })
+      );
+    }
     await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
     try {
       await this.setPendingTxFlag(false);
@@ -9808,12 +9972,17 @@ function selectVirtualCoins(coins, targetAmount) {
 }
 async function waitForIncomingFunds(wallet) {
   let stopFunc;
+  let settled = false;
   return new Promise((resolve) => {
-    wallet.notifyIncomingFunds((coins) => {
-      resolve(coins);
-      if (stopFunc) stopFunc();
+    wallet.notifyIncomingFunds((funds) => {
+      const hasFunds = funds.type === "utxo" ? funds.coins.length > 0 : funds.newVtxos.length > 0;
+      if (settled || !hasFunds) return;
+      settled = true;
+      resolve(funds);
+      stopFunc?.();
     }).then((stop) => {
       stopFunc = stop;
+      if (settled) stop();
     });
   });
 }
@@ -13990,5 +14159,5 @@ function isArkContract(str) {
 }
 
 export { ArkNote, AssetManager, BIP322, Batch, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EsploraProvider, Estimator, HDDescriptorProvider, InMemoryContractRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBWalletRepository, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, buildForfeitTx, buildOffchainTx, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, decodeArkContract, deserializeAssets, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, isArkContract, isBatchSignable, isDiscoverable, isExpired, isRecoverable, isSpendable, isSubdust, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, serializeAssets, serializeUtxo, serializeVtxo, setupServiceWorker, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-HJM6JPG4.js.map
-//# sourceMappingURL=chunk-HJM6JPG4.js.map
+//# sourceMappingURL=chunk-DSS2GQUG.js.map
+//# sourceMappingURL=chunk-DSS2GQUG.js.map