@arkade-os/sdk 0.5.2 → 0.5.3

package/dist/{chunk-AJWXVQYG.js → chunk-HAQAWBYG.js}

@@ -1,6 +1,6 @@
-import { Packet, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-U5XG7SWA.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, UnsupportedProgramVersionError, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, ARKADE_TYPE_ENCODINGS, validateParamValue, contractHandlers, speculativeReceiveMetadata, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-LWRMSC4M.js';
-import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, timelockToSequence, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, getArkPsbtFields, craftToSpendTx, RestArkProvider, ArkAddress, isVirtualCoin, CosignerPublicKey, ServerResponseMismatchError, assertNonNegativeMs, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, baseFetch, DEFAULT_NETWORK_NAME, sequenceToCanonicalTimelock, assertTimerMs, isEventSourceError, isEventSourceUnavailableError, normalizeVtxo, isPastExpiry, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, isArkError, ArkErrorName, assertAllowedSighashTypes, Intent, rateGate, formatSighash, getSequence, maybeArkError, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, DEFAULT_ARKADE_EMULATOR_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-HKG26NUT.js';
+import { Packet, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-6FL4N4S2.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, UnsupportedProgramVersionError, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, ARKADE_TYPE_ENCODINGS, validateParamValue, contractHandlers, speculativeReceiveMetadata, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-P7B4LQ3H.js';
+import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, timelockToSequence, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, RestArkProvider, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, assertNonNegativeMs, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, assertAllowedSighashTypes, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, baseFetch, DEFAULT_NETWORK_NAME, sequenceToCanonicalTimelock, assertTimerMs, isEventSourceError, isEventSourceUnavailableError, normalizeVtxo, isPastExpiry, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, formatSighash, isArkError, ArkErrorName, Intent, rateGate, getSequence, maybeArkError, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, DEFAULT_ARKADE_EMULATOR_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-OPX2HRWM.js';
 import { sha256, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, OP, OutScript, Address, RawWitness, p2tr, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$1 } from '@scure/btc-signer';
 import { hex, base58, base64, bech32m } from '@scure/base';
@@ -3833,32 +3833,36 @@ function assertCheckpointsMatchInputs(checkpoints, inputs, unrollCandidates, con
   }
 }
 async function submitOffchainTx(provider, offchainTx, signer, hooks, options) {
-  const { arkTx: signedArkTx, userSignedCheckpoints } = await signer.signArkTx(
+  const oneShot = options?.oneShot !== false;
+  const { arkTx: signedArkTx, userSignedCheckpoints: batchSigned } = await signer.signArkTx(
     offchainTx.arkTx,
     offchainTx.checkpoints
   );
-  if (userSignedCheckpoints && userSignedCheckpoints.length !== offchainTx.checkpoints.length) {
+  if (batchSigned && batchSigned.length !== offchainTx.checkpoints.length) {
     throw new Error(
-      `signer returned ${userSignedCheckpoints.length} signed checkpoints, expected ${offchainTx.checkpoints.length}`
+      `signer returned ${batchSigned.length} signed checkpoints, expected ${offchainTx.checkpoints.length}`
     );
   }
+  const userSignedCheckpoints = (batchSigned ?? (oneShot ? await Promise.all(offchainTx.checkpoints.map((c) => signer.signCheckpoint(c.clone()))) : void 0))?.map((c) => withArkInputWitness(c, signedArkTx));
   await hooks?.beforeSubmit?.();
   const response = await provider.submitTx(
     base64.encode(signedArkTx.toPSBT()),
-    offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT()))
+    (oneShot ? userSignedCheckpoints : offchainTx.checkpoints.map((c) => withArkInputWitness(c, signedArkTx))).map((c) => base64.encode(c.toPSBT()))
   );
   assertSubmittedArkTxid(response, signedArkTx, "submitTx");
   const { arkTxid, signedCheckpointTxs } = response;
   const matched = matchServerCheckpoints(signedCheckpointTxs, offchainTx.checkpoints, "submitTx");
-  matched.forEach(({ server }, index) => {
-    try {
-      assertAllowedSighashTypes(server);
-    } catch (error) {
-      throw new ServerResponseMismatchError(
-        `submitTx checkpoint ${index}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  });
+  if (!oneShot) {
+    matched.forEach(({ server }, index) => {
+      try {
+        assertAllowedSighashTypes(server);
+      } catch (error) {
+        throw new ServerResponseMismatchError(
+          `submitTx checkpoint ${index}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    });
+  }
   const verify = options?.verifyServerSignatures;
   if (verify) {
     if (response.finalArkTx === void 0) {
@@ -3885,26 +3889,62 @@ async function submitOffchainTx(provider, offchainTx, signer, hooks, options) {
       ({ server, local }, index) => assertServerSignedLeaf(server, local, 0, serverPubkeys, `submitTx checkpoint ${index}`)
     );
   }
+  const result = { arkTxid, finalArkTx: response.finalArkTx, signedCheckpointTxs };
   let finalCheckpoints;
   if (userSignedCheckpoints) {
     const userByTxid = new Map(
       userSignedCheckpoints.map((c, i) => [offchainTx.checkpoints[i].id, c])
     );
+    if (oneShot && matched.every(
+      ({ server, local }) => carriesTapscriptSigs(server, userByTxid.get(local.id))
+    )) {
+      await hooks?.afterFinalize?.();
+      return result;
+    }
     finalCheckpoints = matched.map(({ server, local }) => {
-      combineTapscriptSigs(userByTxid.get(local.id), server);
+      const userSigned = userByTxid.get(local.id);
+      combineTapscriptSigs(userSigned, server);
+      carryConditionWitness(userSigned, server);
       return base64.encode(server.toPSBT());
     });
   } else {
     finalCheckpoints = await Promise.all(
-      matched.map(async ({ server }) => {
+      matched.map(async ({ server, local }) => {
         const signed = await signer.signCheckpoint(server);
+        carryConditionWitness(local, signed);
         return base64.encode(signed.toPSBT());
       })
     );
   }
   await provider.finalizeTx(arkTxid, finalCheckpoints);
   await hooks?.afterFinalize?.();
-  return { arkTxid, signedCheckpointTxs };
+  return result;
+}
+function carryConditionWitness(ours, server) {
+  if (getArkPsbtFields(server, 0, ConditionWitness).length > 0) return;
+  const [witness] = getArkPsbtFields(ours, 0, ConditionWitness);
+  if (witness) setArkPsbtField(server, 0, ConditionWitness, witness);
+}
+function withArkInputWitness(checkpoint, signedArkTx) {
+  if (getArkPsbtFields(checkpoint, 0, ConditionWitness).length > 0) return checkpoint;
+  for (let i = 0; i < signedArkTx.inputsLength; i++) {
+    const { txid } = signedArkTx.getInput(i);
+    if (!txid || hex.encode(txid) !== checkpoint.id) continue;
+    const [witness] = getArkPsbtFields(signedArkTx, i, ConditionWitness);
+    if (!witness) return checkpoint;
+    const carried = checkpoint.clone();
+    setArkPsbtField(carried, 0, ConditionWitness, witness);
+    return carried;
+  }
+  return checkpoint;
+}
+function carriesTapscriptSigs(server, userSigned) {
+  const entries = (tx) => (tx.getInput(0).tapScriptSig ?? []).map(
+    ([{ pubKey, leafHash }, sig]) => hex.encode(pubKey) + hex.encode(leafHash) + hex.encode(sig)
+  );
+  const have = new Set(entries(server));
+  const want = entries(userSigned);
+  return want.length > 0 && want.every((entry) => have.has(entry));
 }
 async function signAndSubmitOffchainTx(params) {
   const offchainTx = buildOffchainTx(params.inputs, params.outputs, params.serverUnrollScript);
@@ -3913,7 +3953,8 @@ async function signAndSubmitOffchainTx(params) {
     signCheckpoint: (checkpoint) => params.identity.sign(checkpoint)
   };
   const { arkTxid } = await submitOffchainTx(params.provider, offchainTx, signer, void 0, {
-    verifyServerSignatures: params.verifyServerSignatures
+    verifyServerSignatures: params.verifyServerSignatures,
+    oneShot: params.oneShot
   });
   return arkTxid;
 }
@@ -14413,7 +14454,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   }
 };
 var Wallet2 = class extends ReadonlyWallet {
-  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, settlementConfig, walletContractTimelocks, receiveRotator, descriptorProvider, keyring, lookAheadWindow, batchExpiryPolicy) {
+  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, settlementConfig, walletContractTimelocks, receiveRotator, descriptorProvider, keyring, lookAheadWindow, batchExpiryPolicy, oneShotSubmit = true) {
     super(
       identity,
       network,
@@ -14433,6 +14474,7 @@ var Wallet2 = class extends ReadonlyWallet {
     this.forfeitOutputScript = forfeitOutputScript;
     this.forfeitPubkey = forfeitPubkey;
     this.batchExpiryPolicy = batchExpiryPolicy;
+    this.oneShotSubmit = oneShotSubmit;
     this.identity = identity;
     this.settlementConfig = settlementConfig !== void 0 ? settlementConfig : { ...DEFAULT_SETTLEMENT_CONFIG };
     this._delegateManager = delegateProvider ? new DelegateManagerImpl(delegateProvider, arkProvider, identity) : void 0;
@@ -14454,6 +14496,7 @@ var Wallet2 = class extends ReadonlyWallet {
   forfeitOutputScript;
   forfeitPubkey;
   batchExpiryPolicy;
+  oneShotSubmit;
   static MIN_FEE_RATE = 1;
   // sats/vbyte
   identity;
@@ -15299,7 +15342,8 @@ var Wallet2 = class extends ReadonlyWallet {
       {
         advertisedVtxoTreeExpiry: setup.info.vtxoTreeExpiry,
         ...config.minBatchExpirySeconds !== void 0 ? { minSeconds: config.minBatchExpirySeconds } : {}
-      }
+      },
+      config.oneShotSubmit
     );
     wallet.lazyInitialization = config.lazyInitialization ?? false;
     wallet._serverInfoSource = setup.serverInfoSource;
@@ -16340,7 +16384,8 @@ var Wallet2 = class extends ReadonlyWallet {
               }
             ],
             outputs: [{ script: myPkScript, amount: BigInt(vtxo.value) }],
-            serverUnrollScript
+            serverUnrollScript,
+            oneShot: this.oneShotSubmit
           });
           swept += vtxo.value;
         } catch (error) {
@@ -17182,7 +17227,8 @@ var Wallet2 = class extends ReadonlyWallet {
             deprecatedServerPubkeys: [...this._deprecatedSigners.keys()].map(
               (h) => hex.decode(h)
             )
-          }
+          },
+          oneShot: this.oneShotSubmit
         }
       );
     } finally {
@@ -17830,6 +17876,7 @@ var MessageBus = class {
         lazyInitialization: config.lazyInitialization,
         watcherConfig: config.watcherConfig,
         lookAheadWindow: config.lookAheadWindow,
+        oneShotSubmit: config.oneShotSubmit,
         minBatchExpirySeconds: config.minBatchExpirySeconds
       });
       return { wallet, arkProvider, readonlyWallet: wallet };
@@ -21071,9 +21118,10 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
   }
 };
 var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
-  constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag, hasDelegate) {
+  constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag, hasDelegate, oneShotSubmit) {
     super(serviceWorker, identity, walletRepository, contractRepository, messageTag);
     this.serviceWorker = serviceWorker;
+    this.oneShotSubmit = oneShotSubmit;
     this.identity = identity;
     this.walletRepository = walletRepository;
     this.contractRepository = contractRepository;
@@ -21084,6 +21132,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
     this.hasDelegate = hasDelegate;
   }
   serviceWorker;
+  oneShotSubmit;
   walletRepository;
   contractRepository;
   identity;
@@ -21120,7 +21169,8 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       walletRepository,
       contractRepository,
       messageTag,
-      !!options.delegateUrl
+      !!options.delegateUrl,
+      options.oneShotSubmit
     );
     wallet._concurrentSpending = options.concurrentSpending === true;
     return _ServiceWorkerWallet.bootstrap(wallet, options, serializedWallet, {
@@ -21131,6 +21181,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       lazyInitialization: options.lazyInitialization,
       watcherConfig: options.watcherConfig,
       lookAheadWindow: options.lookAheadWindow,
+      oneShotSubmit: options.oneShotSubmit,
       minBatchExpirySeconds: options.minBatchExpirySeconds
     });
   }
@@ -24760,6 +24811,7 @@ var Arkade = class _Arkade {
   userKey;
   /** The contract manager, when contract persistence is wired up (passed in or owned). */
   contractManager;
+  oneShotSubmit;
   /** Whether {@link connect} built {@link contractManager}, so {@link dispose} must stop it. */
   ownsContractManager;
   /** {@link ArkadeContract.on} handles by contract script (hex). */
@@ -24779,6 +24831,7 @@ var Arkade = class _Arkade {
     this.identity = fields.identity;
     this.userKey = fields.userKey;
     this.contractManager = fields.contractManager;
+    this.oneShotSubmit = fields.oneShotSubmit;
     this.ownsContractManager = fields.ownsContractManager ?? false;
   }
   /**
@@ -24855,7 +24908,8 @@ var Arkade = class _Arkade {
       identity: opts.identity,
       userKey,
       contractManager,
-      ownsContractManager
+      ownsContractManager,
+      oneShotSubmit: opts.oneShotSubmit
     });
   }
   /**
@@ -25392,7 +25446,8 @@ var ArkadeTransactionBuilder = class {
         inputIndexes: userInputs
       });
     }
-    if (!client.identity) {
+    const identity = client.identity;
+    if (!identity) {
       throw new Error("a signing identity is required for non-covenant spends");
     }
     const ark = client.arkProvider;
@@ -25401,26 +25456,19 @@ var ArkadeTransactionBuilder = class {
         "broadcasting requires an `arkade` provider with `submitTx`/`finalizeTx` on the Arkade client"
       );
     }
-    const signedArk = await this.signArk(arkTx, userInputs);
-    const res = await ark.submitTx(
-      base64.encode(signedArk.toPSBT()),
-      checkpoints.map((c) => base64.encode(c.toPSBT()))
-    );
-    assertSubmittedArkTxid(res, signedArk, "submitTx");
-    const matched = matchServerCheckpoints(res.signedCheckpointTxs, checkpoints, "submitTx");
-    const finalCps = await Promise.all(
-      matched.map(async ({ server, local }) => {
-        const signed = await client.identity.sign(server, [0]);
-        const [condition] = getArkPsbtFields(local, 0, ConditionWitness);
-        if (condition && getArkPsbtFields(signed, 0, ConditionWitness).length === 0) {
-          setArkPsbtField(signed, 0, ConditionWitness, condition);
-        }
-        return base64.encode(signed.toPSBT());
-      })
+    const res = await submitOffchainTx(
+      ark,
+      { arkTx, checkpoints },
+      {
+        signArkTx: async (tx) => ({ arkTx: await this.signArk(tx, userInputs) }),
+        signCheckpoint: (checkpoint) => identity.sign(checkpoint, [0])
+      },
+      void 0,
+      { oneShot: client.oneShotSubmit }
     );
-    await ark.finalizeTx(res.arkTxid, finalCps);
     return {
       txid: res.arkTxid,
+      // Required by ArkadeBroadcaster; RestArkProvider.submitTx rejects a response without it.
       signedArkTx: res.finalArkTx,
       signedCheckpointTxs: res.signedCheckpointTxs
     };
@@ -25987,5 +26035,5 @@ function createDefaultPaymentRouter(wallet) {
 }
 
 export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, Arkade, ArkadeCash, ArkadeCashCreateError, ArkadeCashOperatorMismatchError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractWatcher, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, KeyringDescriptorProvider, MAX_PAGE_SIZE, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, OversizedChangeError, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestEmulatorProvider, SeedIdentity, SendDeadlineExceededError, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, StaticDescriptorProvider, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, VtxoReservedError, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertHistoryPageFilter, assertIntentIdUnique, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, checkSaveVtxosForScript, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, compareHistoryCursors, contractFilterMatchesNothing, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, createdAtToIso, decodeArkContract, defaultBatchExpiryPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, legacyVtxoFacts, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, submitViaEmulator, toXOnlySignerHex, tryResolveSendAmount, utxoEntries, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
-//# sourceMappingURL=chunk-AJWXVQYG.js.map
-//# sourceMappingURL=chunk-AJWXVQYG.js.map
+//# sourceMappingURL=chunk-HAQAWBYG.js.map
+//# sourceMappingURL=chunk-HAQAWBYG.js.map