@arkade-os/sdk 0.5.1 → 0.5.3

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { ah as ReadonlyIdentity, a as Identity, a4 as DescriptorSigningRequest, a5 as Transaction, aB as SignerSession, a3 as DescriptorProvider, aF as IntentFeeConfig, aG as OffchainInput, aH as FeeAmount, aI as OnchainInput, aJ as FeeOutput, Y as IntentRepository, Z as ArkIntent, _ as IntentPageFilter, P as PageRequest, F as PageResult, O as Outpoint, $ as VirtualTxRepository, a0 as VirtualTx, a1 as VtxoBranch, W as WalletRepository, D as ExtendedVirtualCoin, H as ScriptVtxoCursor, J as ScriptVtxoPageOptions, K as StoredVtxo, L as VtxoRepositoryKey, E as ExtendedCoin, M as TransactionHistoryPageFilter, Q as TransactionHistoryPageCursor, h as ArkTransaction, U as WalletState, B as Contract, C as ContractRepository, X as ContractFilter, I as IWallet, v as ArkProvider, ar as NetworkName, ai as OnchainProvider, az as SettlementConfig, aK as ContractWatcherConfig, aL as Asset, R as Recipient, aM as FeeInfo, o as SettlementEvent, N as NormalizedExtendedVirtualCoin, S as SettleParams, G as GetArkadeInfoOptions, aN as GetVtxosOptions, aO as PaginationOptions, f as GetVtxosFilter, g as GetSpendableVtxosFilter, aP as CreateContractParams, aQ as GetContractsFilter, z as VirtualCoin, aR as GetSpendablePathsOptions, aS as GetAllSpendingPathsOptions, l as GetNewAddressesOptions, aT as InputExpiryFloor, aU as IssuanceParams, aV as ReissuanceParams, aW as BurnParams, aX as RenewVtxosOptions, A as ArkadeInfo, aY as NormalizedVtxoPage, c as ArkadeReader, d as ArkadeBroadcaster, e as WalletBalance, ao as ContractSyncState, at as ContractWithVtxos, aZ as WatchedScript, a_ as PathSelection, m as NewAddress, a$ as ContractEvent, b0 as AssetDetails, b1 as IssuanceResult, b2 as DelegateInfo, b3 as MigrationGlobalSkipReason, b4 as MigrationLegSkipReason, b5 as SignerStatus, ag as IReadonlyWallet, i as ActivityRegistry, an as IReadonlyAssetManager, b6 as StorageConfig, j as Activity, k as IContractManager, q as IAssetManager, p as SendParams, n as IDelegateManager, b7 as IVtxoManager, a6 as Network, av as Coin, b8 as SendBitcoinParams, b9 as ExplorerTransaction, aC as SignedIntent, aD as Intent, ba as TreeNonces, bb as TreePartialSigs, T as TxNotificationEvent, bc as PendingTx, y as TapLeafScript, bd as EncodedVtxoScript, ay as CSVMultisigTapscript, x as RelativeTimelock, be as EmulatorProvider, V as VtxoScript, bf as Status, as as ArkAddress, bg as ChainTx, w as IndexerProvider, a9 as TxTree, bh as ArkadeService, bi as ContractVtxoEvent, bj as ExtendedContractVtxo, bk as ResolvedArkadeService, bl as resolveArkadeService, bm as PathContext } from './index-B3fRWO5i.js';
-export { bn as ActivityIntent, bo as ActivityResolver, bp as ArkIntentState, bq as ArkTapscript, br as AssetMetadata, bs as BITCOIN_EMULATOR_PUBKEY, bt as BaseWalletConfig, ad as BatchFailedEvent, ab as BatchFinalizationEvent, ac as BatchFinalizedEvent, bu as BatchInfo, bv as BatchSignableIdentity, a7 as BatchStartedEvent, bw as CLTVMultisigTapscript, bx as CandidateDeps, by as ChainTxType, a2 as ChainedTxType, bz as CommitmentTx, bA as ConditionCSVMultisigTapscript, bB as ConditionMultisigTapscript, bC as ConnectorTreeNode, bD as ContractBalance, bE as ContractEventCallback, bF as ContractHandler, aw as ContractManager, ax as ContractManagerConfig, bG as ContractState, bH as ContractVtxo, bI as ContractWatcher, bJ as ContractWatcherEventCallback, bK as DEFAULT_ARKADE_EMULATOR_URL, bL as DEFAULT_VTXO_PAGE_SIZE, bM as DelegateManagerImpl, bN as DelegateOptions, aj as DelegateProvider, bO as DeprecatedSignerMigrationReport, bP as DeprecatedSignerReport, bQ as DigestMismatchError, bR as Discoverable, bS as DiscoveredContract, bT as DiscoveryDeps, bU as ESPLORA_URL, bV as EmulatorInfo, aq as EsploraProvider, bW as EventSourceCapable, bX as EventSourceFactory, bY as EventSourceLike, bZ as EventSourceUnavailableError, al as ExitCaptureMode, b_ as ExitChainResolver, am as ExitDataSource, b$ as GroupMembership, c0 as HandlerError, c1 as INTENT_TERMINAL_STATES, c2 as IndexerTxType, c3 as IntentCoin, c4 as IntentFilter, c5 as KnownMetadata, c6 as MAX_PAGE_SIZE, c7 as MUTINYNET_EMULATOR_PUBKEY, c8 as MigrateDeprecatedSignerOptions, c9 as MigrationLegReport, ca as MigrationVtxoRef, cb as MultisigTapscript, cc as NewAddressType, cd as Nonces, ce as Output, cf as PageResponse, cg as PartialSig, ch as PrevTxSource, ci as PrevTxUnavailableError, cj as ProviderClass, ck as REGTEST_EMULATOR_PUBKEY, cl as RawTxSource, ak as ReadonlyWalletConfig, ap as RecipientArkadeAddressContext, cm as RenewalSplit, cn as RenewalSplitContext, r as RestArkProvider, co as RestDelegateProvider, cp as RestEmulatorProvider, s as RestIndexerProvider, cq as ScanContractsOptions, cr as ScanResult, cs as ScheduledSession, ct as SettlementEventType, cu as SignRequest, cv as SignerClassification, cw as SignerSet, t as SubscriptionEvent, cx as SubscriptionFilter, u as SubscriptionHeartbeat, cy as SubscriptionResponse, cz as SweepTxNotification, cA as TapLeaves, cB as TapTreeCoder, cC as TapscriptType, aE as TimeHeight, aa as TreeNoncesEvent, af as TreeSignatureEvent, a8 as TreeSigningStartedEvent, ae as TreeTxEvent, cD as Tx, cE as TxHistoryRecord, cF as TxKey, cG as TxNotification, cH as TxTag, cI as TxTreeNode, cJ as TxType, cK as Vtxo, cL as VtxoChain, aA as VtxoManager, cM as VtxoType, b as WalletConfig, cN as WalletMode, cO as WithPrevTx, cP as assertAllowedSighashTypes, cQ as assertPageRequest, cR as assertRecipientArkadeAddress, cS as assetMintResolver, cT as attachPrevArkTxs, cU as attachPrevoutTxs, cV as boardingResolver, cW as canRecoverOnchain, cX as canSpendOffchain, cY as canSweepOnchain, cZ as classifyAgainstSignerSet, c_ as classifyContractSigner, c$ as collabExitResolver, d0 as collectContracts, d1 as collectIntents, d2 as collectPages, d3 as collectScriptVtxos, d4 as collectTransactionHistory, d5 as collectUtxos, d6 as collectVtxos, d7 as configureEventSource, d8 as createDefaultActivityRegistry, d9 as createExitChainResolver, da as decodeTapscript, db as defaultEmulatorPubkey, dc as getAllNormalizedVtxos, dd as getConfiguredEventSource, de as getNetwork, df as getNormalizedVtxos, dg as getRandomId, dh as getSequence, di as hasCandidates, dj as isBatchSignable, dk as isContractVtxoEvent, dl as isCooperativelyMigratable, dm as isDiscoverable, dn as isEventSourceUnavailableError, dp as isPastExpiry, dq as isSigningIdentity, dr as isSubdust, ds as isTerminalIntentState, dt as isVirtualCoin, du as isVtxoExpiringSoon, dv as isVtxoSpent, dw as iteratePages, dx as networkFromArkadeInfo, dy as networks, dz as pageResult, dA as resolveEmulatorPubkey, dB as resolveEventSource, dC as resolvePrevTxs, dD as scriptFromTapLeafScript, dE as signerSetFromInfo, dF as toOffchainInputFeeParams, dG as toXOnlySignerHex, dH as withPrevTxs } from './index-B3fRWO5i.js';
-import { W as Wallet, R as ReadonlyWallet, b as ReceiveRotatorFactory, c as ReceiveRotatorBootOpts, d as ReceiveRotatorBoot, P as ProviderConnectionState, H as HDWalletCapable, a as HDAllocationCapable, A as AddressAllocationCapable, B as BatchExpiryPolicy, e as Batch } from './wallet-BQHNgc_v.js';
-export { f as AbortError, g as ArkError, h as ArkErrorName, i as ArkadeCashClaimResult, j as ArkadeCashCreateError, k as ArkadeCashOperatorMismatchError, l as ArkadeCashUnclaimedReason, m as ArkadeCashUnclaimedVtxo, n as ArkadeCashVtxoRef, o as BoardingUtxoGroup, D as DEFAULT_MIN_BATCH_EXPIRY_SECONDS, F as ForeignDescriptorError, I as IncomingFunds, p as IndexedDBWalletRepository, K as KeyringDescriptorProvider, M as MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, q as ProviderKind, r as ProviderUnavailableError, s as REGTEST_MIN_BATCH_EXPIRY_SECONDS, S as ServerInfoSource, t as ServerResponseMismatchError, V as VtxoReservation, u as VtxoReservedError, v as WaitForIncomingFundsOptions, w as WalletCannotAllocateAddressError, x as assertValidBatchExpiry, y as defaultBatchExpiryPolicy, z as isAddressAllocationCapable, C as isArkError, E as isHDAllocationCapable, G as isHDWalletCapable, J as maybeArkError, L as resolveBatchExpiryPolicy, N as resolveDescriptorSigner, O as selectVirtualCoins, Q as signingDescriptorIndex, T as strictSigningDescriptorIndex, U as waitForIncomingFunds } from './wallet-BQHNgc_v.js';
-import { P as Program, A as ArkadeParamValue, a as ArkadeProgramScript, b as ProgramKeys, c as ArkadeArgValue, C as CompiledProgramFunction, d as ArkadeFunction, I as InputDef, e as ArkadeValueType, f as ArkadeArgType, g as ArkadeContractParams, h as ArkadeSegment, i as AsmToken, j as InputRef, S as SUPPORTED_PROGRAM_VERSION, k as SignerRef, T as TapscriptSegment, l as TweakedSigner, U as UnsupportedProgramVersionError, W as WitnessRef, m as deserializeArkadeContractParams, p as parseArtifact, r as resolveAsm, s as serializeArkadeContractParams, n as stringifyArtifact, v as validateProgram, w as witnessRefToBytes } from './index-CzUVvIxA.js';
-export { o as ArkadeContractHandler, B as BoardingContractHandler, q as BoardingContractParams, D as DefaultContractHandler, t as DefaultContractParams, u as DelegateContractHandler, x as DelegateContractParams, V as VHTLC, y as VHTLCContractHandler, z as VHTLCContractParams, E as VHTLCV2ContractHandler, F as VHTLCV2ContractParams, G as contractHandlers } from './index-CzUVvIxA.js';
-import { D as DefaultVtxo } from './delegate-BSbGQabI.js';
-export { a as DelegateVtxo } from './delegate-BSbGQabI.js';
+import { ah as ReadonlyIdentity, a as Identity, a4 as DescriptorSigningRequest, a5 as Transaction, aB as SignerSession, a3 as DescriptorProvider, aF as IntentFeeConfig, aG as OffchainInput, aH as FeeAmount, aI as OnchainInput, aJ as FeeOutput, Y as IntentRepository, Z as ArkIntent, _ as IntentPageFilter, P as PageRequest, F as PageResult, O as Outpoint, $ as VirtualTxRepository, a0 as VirtualTx, a1 as VtxoBranch, W as WalletRepository, D as ExtendedVirtualCoin, H as ScriptVtxoCursor, J as ScriptVtxoPageOptions, K as StoredVtxo, L as VtxoRepositoryKey, E as ExtendedCoin, M as TransactionHistoryPageFilter, Q as TransactionHistoryPageCursor, h as ArkTransaction, U as WalletState, B as Contract, C as ContractRepository, X as ContractFilter, I as IWallet, v as ArkProvider, ar as NetworkName, ai as OnchainProvider, az as SettlementConfig, aK as ContractWatcherConfig, aL as Asset, R as Recipient, aM as FeeInfo, o as SettlementEvent, N as NormalizedExtendedVirtualCoin, S as SettleParams, G as GetArkadeInfoOptions, aN as GetVtxosOptions, aO as PaginationOptions, f as GetVtxosFilter, g as GetSpendableVtxosFilter, aP as CreateContractParams, aQ as GetContractsFilter, z as VirtualCoin, aR as GetSpendablePathsOptions, aS as GetAllSpendingPathsOptions, l as GetNewAddressesOptions, aT as InputExpiryFloor, aU as IssuanceParams, aV as ReissuanceParams, aW as BurnParams, aX as RenewVtxosOptions, A as ArkadeInfo, aY as NormalizedVtxoPage, c as ArkadeReader, d as ArkadeBroadcaster, e as WalletBalance, ao as ContractSyncState, at as ContractWithVtxos, aZ as WatchedScript, a_ as PathSelection, m as NewAddress, a$ as ContractEvent, b0 as AssetDetails, b1 as IssuanceResult, b2 as DelegateInfo, b3 as MigrationGlobalSkipReason, b4 as MigrationLegSkipReason, b5 as SignerStatus, ag as IReadonlyWallet, i as ActivityRegistry, an as IReadonlyAssetManager, b6 as StorageConfig, j as Activity, k as IContractManager, q as IAssetManager, p as SendParams, n as IDelegateManager, b7 as IVtxoManager, a6 as Network, av as Coin, b8 as SendBitcoinParams, b9 as ExplorerTransaction, aC as SignedIntent, aD as Intent, ba as TreeNonces, bb as TreePartialSigs, T as TxNotificationEvent, bc as PendingTx, y as TapLeafScript, bd as EncodedVtxoScript, ay as CSVMultisigTapscript, x as RelativeTimelock, be as EmulatorProvider, V as VtxoScript, bf as Status, as as ArkAddress, bg as ChainTx, w as IndexerProvider, a9 as TxTree, bh as ArkadeService, bi as ContractVtxoEvent, bj as ExtendedContractVtxo, bk as ResolvedArkadeService, bl as resolveArkadeService, bm as PathContext } from './index-BURzbRup.js';
+export { bn as ActivityIntent, bo as ActivityResolver, bp as ArkIntentState, bq as ArkTapscript, br as AssetMetadata, bs as BITCOIN_EMULATOR_PUBKEY, bt as BaseWalletConfig, ad as BatchFailedEvent, ab as BatchFinalizationEvent, ac as BatchFinalizedEvent, bu as BatchInfo, bv as BatchSignableIdentity, a7 as BatchStartedEvent, bw as CLTVMultisigTapscript, bx as CandidateDeps, by as ChainTxType, a2 as ChainedTxType, bz as CommitmentTx, bA as ConditionCSVMultisigTapscript, bB as ConditionMultisigTapscript, bC as ConnectorTreeNode, bD as ContractBalance, bE as ContractEventCallback, bF as ContractHandler, aw as ContractManager, ax as ContractManagerConfig, bG as ContractState, bH as ContractVtxo, bI as ContractWatcher, bJ as ContractWatcherEventCallback, bK as DEFAULT_ARKADE_EMULATOR_URL, bL as DEFAULT_VTXO_PAGE_SIZE, bM as DelegateManagerImpl, bN as DelegateOptions, aj as DelegateProvider, bO as DeprecatedSignerMigrationReport, bP as DeprecatedSignerReport, bQ as DigestMismatchError, bR as Discoverable, bS as DiscoveredContract, bT as DiscoveryDeps, bU as ESPLORA_URL, bV as EmulatorInfo, aq as EsploraProvider, bW as EventSourceCapable, bX as EventSourceFactory, bY as EventSourceLike, bZ as EventSourceUnavailableError, al as ExitCaptureMode, b_ as ExitChainResolver, am as ExitDataSource, b$ as GroupMembership, c0 as HandlerError, c1 as INTENT_TERMINAL_STATES, c2 as IndexerTxType, c3 as IntentCoin, c4 as IntentFilter, c5 as KnownMetadata, c6 as MAX_PAGE_SIZE, c7 as MUTINYNET_EMULATOR_PUBKEY, c8 as MigrateDeprecatedSignerOptions, c9 as MigrationLegReport, ca as MigrationVtxoRef, cb as MultisigTapscript, cc as NewAddressType, cd as Nonces, ce as Output, cf as PageResponse, cg as PartialSig, ch as PrevTxSource, ci as PrevTxUnavailableError, cj as ProviderClass, ck as REGTEST_EMULATOR_PUBKEY, cl as RawTxSource, ak as ReadonlyWalletConfig, ap as RecipientArkadeAddressContext, cm as RenewalSplit, cn as RenewalSplitContext, r as RestArkProvider, co as RestDelegateProvider, cp as RestEmulatorProvider, s as RestIndexerProvider, cq as ScanContractsOptions, cr as ScanResult, cs as ScheduledSession, ct as SettlementEventType, cu as SignRequest, cv as SignerClassification, cw as SignerSet, t as SubscriptionEvent, cx as SubscriptionFilter, u as SubscriptionHeartbeat, cy as SubscriptionResponse, cz as SweepTxNotification, cA as TapLeaves, cB as TapTreeCoder, cC as TapscriptType, aE as TimeHeight, aa as TreeNoncesEvent, af as TreeSignatureEvent, a8 as TreeSigningStartedEvent, ae as TreeTxEvent, cD as Tx, cE as TxHistoryRecord, cF as TxKey, cG as TxNotification, cH as TxTag, cI as TxTreeNode, cJ as TxType, cK as Vtxo, cL as VtxoChain, aA as VtxoManager, cM as VtxoType, b as WalletConfig, cN as WalletMode, cO as WithPrevTx, cP as assertAllowedSighashTypes, cQ as assertPageRequest, cR as assertRecipientArkadeAddress, cS as assetMintResolver, cT as attachPrevArkTxs, cU as attachPrevoutTxs, cV as boardingResolver, cW as canRecoverOnchain, cX as canSpendOffchain, cY as canSweepOnchain, cZ as classifyAgainstSignerSet, c_ as classifyContractSigner, c$ as collabExitResolver, d0 as collectContracts, d1 as collectIntents, d2 as collectPages, d3 as collectScriptVtxos, d4 as collectTransactionHistory, d5 as collectUtxos, d6 as collectVtxos, d7 as configureEventSource, d8 as createDefaultActivityRegistry, d9 as createExitChainResolver, da as decodeTapscript, db as defaultEmulatorPubkey, dc as getAllNormalizedVtxos, dd as getConfiguredEventSource, de as getNetwork, df as getNormalizedVtxos, dg as getRandomId, dh as getSequence, di as hasCandidates, dj as isBatchSignable, dk as isContractVtxoEvent, dl as isCooperativelyMigratable, dm as isDiscoverable, dn as isEventSourceUnavailableError, dp as isPastExpiry, dq as isSigningIdentity, dr as isSubdust, ds as isTerminalIntentState, dt as isVirtualCoin, du as isVtxoExpiringSoon, dv as isVtxoSpent, dw as iteratePages, dx as networkFromArkadeInfo, dy as networks, dz as pageResult, dA as resolveEmulatorPubkey, dB as resolveEventSource, dC as resolvePrevTxs, dD as scriptFromTapLeafScript, dE as signerSetFromInfo, dF as toOffchainInputFeeParams, dG as toXOnlySignerHex, dH as withPrevTxs } from './index-BURzbRup.js';
+import { W as Wallet, R as ReadonlyWallet, b as ReceiveRotatorFactory, c as ReceiveRotatorBootOpts, d as ReceiveRotatorBoot, P as ProviderConnectionState, H as HDWalletCapable, a as HDAllocationCapable, A as AddressAllocationCapable, B as BatchExpiryPolicy, e as Batch } from './wallet-BnmhohgZ.js';
+export { f as AbortError, g as ArkError, h as ArkErrorName, i as ArkadeCashClaimResult, j as ArkadeCashCreateError, k as ArkadeCashOperatorMismatchError, l as ArkadeCashUnclaimedReason, m as ArkadeCashUnclaimedVtxo, n as ArkadeCashVtxoRef, o as BoardingUtxoGroup, D as DEFAULT_MIN_BATCH_EXPIRY_SECONDS, F as ForeignDescriptorError, I as IncomingFunds, p as IndexedDBWalletRepository, K as KeyringDescriptorProvider, M as MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, q as ProviderKind, r as ProviderUnavailableError, s as REGTEST_MIN_BATCH_EXPIRY_SECONDS, S as ServerInfoSource, t as ServerResponseMismatchError, V as VtxoReservation, u as VtxoReservedError, v as WaitForIncomingFundsOptions, w as WalletCannotAllocateAddressError, x as assertValidBatchExpiry, y as defaultBatchExpiryPolicy, z as isAddressAllocationCapable, C as isArkError, E as isHDAllocationCapable, G as isHDWalletCapable, J as maybeArkError, L as resolveBatchExpiryPolicy, N as resolveDescriptorSigner, O as selectVirtualCoins, Q as signingDescriptorIndex, T as strictSigningDescriptorIndex, U as waitForIncomingFunds } from './wallet-BnmhohgZ.js';
+import { P as Program, A as ArkadeParamValue, a as ArkadeProgramScript, b as ProgramKeys, c as ArkadeArgValue, d as ArkadeFunction, I as InputDef, e as ArkadeValueType, C as CompiledProgramFunction, f as ArkadeArgType, g as ArkadeContractParams, h as ArkadeSegment, i as AsmToken, j as InputRef, S as SUPPORTED_PROGRAM_VERSION, k as SignerRef, T as TapscriptSegment, l as TweakedSigner, U as UnsupportedProgramVersionError, W as WitnessRef, m as deserializeArkadeContractParams, p as parseArtifact, r as resolveAsm, s as serializeArkadeContractParams, n as stringifyArtifact, v as validateProgram, w as witnessRefToBytes } from './index-B6X2E7W_.js';
+export { o as ArkadeContractHandler, B as BoardingContractHandler, q as BoardingContractParams, D as DefaultContractHandler, t as DefaultContractParams, u as DelegateContractHandler, x as DelegateContractParams, V as VHTLC, y as VHTLCContractHandler, z as VHTLCContractParams, E as VHTLCV2ContractHandler, F as VHTLCV2ContractParams, G as contractHandlers } from './index-B6X2E7W_.js';
+import { D as DefaultVtxo } from './delegate-Cd28gxpM.js';
+export { a as DelegateVtxo } from './delegate-Cd28gxpM.js';
 import { Bytes, BTC_NETWORK } from '@scure/btc-signer/utils.js';
 import { P2TR } from '@scure/btc-signer/payment.js';
 import { Transaction as Transaction$1, OP, Script, ScriptType } from '@scure/btc-signer';
@@ -1066,6 +1066,8 @@ type Initialize = {
         watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
         /** @see WalletConfig.lookAheadWindow */
         lookAheadWindow?: number;
+        /** @see WalletConfig.oneShotSubmit */
+        oneShotSubmit?: boolean;
         /** @see WalletConfig.minBatchExpirySeconds */
         minBatchExpirySeconds?: bigint;
         /**
@@ -2788,10 +2790,16 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     private indexerProvider;
     private walletRepository;
     private incomingFundsSubscription;
+    private incomingFundsRegistrations;
     private contractEventsSubscription;
     private onNextTick;
     private channel;
     private incomingFundsEpoch;
+    /**
+     * Supersedes older initializers without touching `incomingFundsEpoch`, so a
+     * re-init that fails before registering leaves the live subscription delivering.
+     */
+    private initEpoch;
     private contractEventsEpoch;
     private boardingEpoch;
     /** Per-request progress callbacks: ends with the handler, not with a re-init. */
@@ -2835,6 +2843,7 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     private handleGetBalance;
     private getBoardingUtxosForBalance;
     private onWalletInitialized;
+    private registerIncomingFunds;
     /**
      * Refresh boarding inputs and transaction history. The virtual outputs come
      * from the contract manager, which runs before this. Shared by
@@ -2845,8 +2854,9 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
      * off the caller's path. @see RequestInitWallet.payload.lazyBoarding
      */
     private refreshCachedData;
-    /** @param gen - set by a background caller; each write is skipped once it goes stale. */
-    private refreshHistoryCache;
+    /** History rows plus the address they are stored under. Does not write. */
+    private loadHistoryCache;
+    private storeHistoryCache;
     /**
      * @param gen - set by a background caller; each write here is skipped once it goes stale.
      *   The fetch saves the fetched rows itself, before control returns, so that one write is
@@ -2994,6 +3004,8 @@ interface ServiceWorkerWalletOptions {
      * @see WalletConfig.lookAheadWindow
      */
     lookAheadWindow?: number;
+    /** @see WalletConfig.oneShotSubmit */
+    oneShotSubmit?: boolean;
     /**
      * Batch expiry floor forwarded to the worker wallet. Lowering it below its
      * per-network default relaxes a fund-safety bound; intended for local
@@ -3044,6 +3056,7 @@ type MessageBusInitConfig = {
     walletMode?: ServiceWorkerWalletMode;
     watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
     lookAheadWindow?: number;
+    oneShotSubmit?: boolean;
     minBatchExpirySeconds?: bigint;
     messageTimeouts?: Record<string, number>;
 };
@@ -3167,6 +3180,7 @@ declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
 }
 declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements IWallet, HDWalletCapable, HDAllocationCapable, AddressAllocationCapable {
     readonly serviceWorker: ServiceWorker;
+    readonly oneShotSubmit?: boolean | undefined;
     readonly walletRepository: WalletRepository;
     readonly contractRepository: ContractRepository;
     readonly identity: Identity;
@@ -3176,7 +3190,7 @@ declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements
     private _concurrentSpending;
     /** @see WalletConfig.concurrentSpending */
     get concurrentSpending(): boolean;
-    protected constructor(serviceWorker: ServiceWorker, identity: Identity, walletRepository: WalletRepository, contractRepository: ContractRepository, messageTag: string, hasDelegate: boolean);
+    protected constructor(serviceWorker: ServiceWorker, identity: Identity, walletRepository: WalletRepository, contractRepository: ContractRepository, messageTag: string, hasDelegate: boolean, oneShotSubmit?: boolean | undefined);
     get assetManager(): IAssetManager;
     static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerWallet>;
     /**
@@ -3886,6 +3900,8 @@ declare function assertSubmittedArkTxid(response: {
  * server at `submitTx`, before any of this runs. What it buys is a loud,
  * immediate failure instead of a caller reporting success, watching nothing
  * confirm, and learning the truth when the counterparty's refund lands.
+ * Under one-shot submit the server has already finalized when it runs, so it
+ * reports a bad response rather than preventing one.
  */
 interface VerifyServerSignatures {
     /** The Ark server's key; x-only or compressed, both accepted. */
@@ -3916,6 +3932,7 @@ declare function signAndSubmitOffchainTx(params: {
     serverUnrollScript: CSVMultisigTapscript.Type;
     /** Forwarded to {@link submitOffchainTx}; omitted, nothing is checked. */
     verifyServerSignatures?: VerifyServerSignatures;
+    oneShot?: boolean;
 }): Promise<string>;
 /**
  * Sign the caller's inputs of a pre-built offchain tx and submit it through the emulator, which
@@ -5437,25 +5454,60 @@ type ArgsTuple<I extends readonly InputDef[]> = {
 type FnArgs<F extends ArkadeFunction> = F extends {
     inputs: infer I extends readonly InputDef[];
 } ? ArgsTuple<I> : [];
+/** A contract's functions returning `R`: typed per function for a literal program, else loose. */
+type FunctionMap<P extends Program, R> = string extends keyof P["functions"] ? Record<string, (...args: ArkadeArgValue[]) => R> : {
+    [K in keyof P["functions"]]: (...args: FnArgs<P["functions"][K]>) => R;
+};
 /**
  * The statically-typed `functions` map of a contract: precisely typed per function for a literal
  * program, the loose {@link CallableFunctions} for the widened {@link Program}.
  */
-type ContractFunctions<P extends Program> = string extends keyof P["functions"] ? CallableFunctions : {
-    [K in keyof P["functions"]]: (...args: FnArgs<P["functions"][K]>) => ArkadeTransactionBuilder;
-};
+type ContractFunctions<P extends Program> = FunctionMap<P, ArkadeTransactionBuilder>;
+/** The statically-typed `unlock` map of a contract, typed like {@link ContractFunctions}. */
+type ContractUnlockers<P extends Program> = FunctionMap<P, ArkadeUnlocker>;
 /** A spendable coin (VTXO) — outpoint + value. */
 interface Utxo {
     txid: string;
     vout: number;
     value: number;
     /**
-     * Raw bytes of the ark tx that created this VTXO, attached as input 0's PrevArkTx. Overrides
+     * The coin's scriptPubKey (hex), as {@link ArkadeContract.getUtxos} returns it. When set,
+     * `.from()` refuses the coin unless it matches the contract spending it.
+     */
+    script?: string;
+    /**
+     * Whether the server swept the coin's batch, as {@link ArkadeContract.getUtxos} reports it. A
+     * swept coin can't be spent offchain, so `.from()` refuses it; recover it into a batch instead.
+     */
+    isSwept?: boolean;
+    /**
+     * When a virtual coin's batch expires, as {@link ArkadeContract.getUtxos} reports it. From that
+     * moment on, `.from()` refuses the coin. A coin without it, such as an onchain one, is never
+     * refused for expiry; height-based expiry isn't checked, since that needs the chain tip.
+     */
+    expiresAt?: Date;
+    /**
+     * Assets the coin carries, as {@link ArkadeContract.getUtxos} reports them. arkd refuses an
+     * input whose assets the spend does not route, so `send()` needs a `.withAsset()` input or a
+     * caller's asset packet for such a coin, and selection without `.from()` skips it otherwise.
+     */
+    assets?: readonly Asset[];
+    /**
+     * Raw bytes of the ark tx that created this VTXO, attached as its input's PrevArkTx. Overrides
      * the indexer-resolved value; supply it when the tx isn't indexable yet (a recursive covenant
      * spending an ark tx the caller just built).
      */
     sourceTx?: Uint8Array;
 }
+/**
+ * A contract function bound to its call arguments, from `contract.unlock.<name>(...args)`.
+ * Pass it to {@link ArkadeTransactionBuilder.from} to spend coins through that function.
+ */
+interface ArkadeUnlocker {
+    readonly contract: ArkadeContract<any>;
+    readonly fn: CompiledProgramFunction;
+    readonly args: Record<string, ArkadeArgValue>;
+}
 /**
  * An asset-group transfer attached to a spend: which inputs supply the asset and
  * which outputs receive it. Encoded into the asset Packet alongside the emulator
@@ -5515,6 +5567,9 @@ interface ArkadeConnectCommonOptions {
      * instead of the indexer. Never disposed by {@link Arkade.dispose}.
      */
     contractManager?: IContractManager;
+    /** For pure-tapscript spends; a client built for a wallet passes `wallet.oneShotSubmit`.
+     * @see WalletConfig.oneShotSubmit */
+    oneShotSubmit?: boolean;
 }
 /**
  * The one-liner form: name the deployment, and `connect` resolves the providers (and, for
@@ -5602,6 +5657,7 @@ declare class Arkade {
     readonly userKey?: Uint8Array;
     /** The contract manager, when contract persistence is wired up (passed in or owned). */
     readonly contractManager?: IContractManager;
+    readonly oneShotSubmit?: boolean;
     /** Whether {@link connect} built {@link contractManager}, so {@link dispose} must stop it. */
     private readonly ownsContractManager;
     /** {@link ArkadeContract.on} handles by contract script (hex). */
@@ -5642,6 +5698,11 @@ declare class Arkade {
      * artifacts reserve the server key and exit delay to the connected server.
      */
     contract<const P extends Program>(program: P, args?: Record<string, ArkadeParamValue>): ArkadeContract<P>;
+    /**
+     * Start a spend with no function of its own: each `.from(coins, contract.unlock.<name>(...))`
+     * names the function its coins are spent through.
+     */
+    transaction(): ArkadeTransactionBuilder;
 }
 /** A resolved, instantiated Arkade contract. */
 declare class ArkadeContract<P extends Program = Program> {
@@ -5670,6 +5731,8 @@ declare class ArkadeContract<P extends Program = Program> {
     get pkScript(): Uint8Array;
     /** Callable spending paths: `functions.<name>(...args)` (see {@link ContractFunctions}). */
     get functions(): ContractFunctions<P>;
+    /** Spending paths bound to their arguments, for `.from(coins, contract.unlock.<name>(...))`. */
+    get unlock(): ContractUnlockers<P>;
     /**
      * The `createContract` payload (serialized program, args, keys, script, address), for
      * registering through a manager the client does not hold.
@@ -5723,25 +5786,33 @@ declare class ArkadeContract<P extends Program = Program> {
     getBalance(): Promise<bigint>;
 }
 /**
- * Fluent builder for a single spend. Obtained from `contract.functions.<name>(...)`;
- * chain `.from()`/`.to()` then `.send()` (broadcast) or `.build()` (assemble only).
+ * Fluent builder for a single spend. Obtained from `contract.functions.<name>(...)`, or from
+ * `ark.transaction()` with no function of its own; chain `.from()`/`.to()` then `.send()`
+ * (broadcast) or `.build()` (assemble only).
  */
 declare class ArkadeTransactionBuilder {
-    private readonly contract;
-    private readonly fn;
-    private readonly args;
+    private readonly client;
+    private readonly unlocker?;
     private readonly outputs;
     private readonly fundingCoins;
     private readonly assetSpecs;
     private readonly extraPackets;
-    private coin?;
+    private readonly inputs;
     private changeScript?;
     /** @internal */
-    constructor(contract: ArkadeContract<any>, fn: CompiledProgramFunction, args: Record<string, ArkadeArgValue>);
-    from(coin: Utxo): this;
+    constructor(client: Arkade, unlocker?: ArkadeUnlocker | undefined);
+    /**
+     * Spend coins through this builder's function, or through `unlocker`
+     * (`other.unlock.<name>(...args)`, same client), which `ark.transaction()` requires. Calls add
+     * up; contract coins come first, in call order, then `.fund()` inputs.
+     *
+     * Every coin's script sees the same outputs: "output 0 pays X" passes once for all of them.
+     * For one payment per coin, the contract must check `INSPECTNUMINPUTS` or `PUSHCURRENTINPUTINDEX`.
+     */
+    from(coins: Utxo | Utxo[], unlocker?: ArkadeUnlocker | undefined): this;
     /**
      * Add extra inputs the caller funds (e.g. a taker's own coins in a swap).
-     * These become inputs 1..n and are signed with the client identity.
+     * These come after the contract coins and are signed with the client identity.
      */
     fund(coins: ArkTxInput[]): this;
     /** Transfer an asset group: which inputs supply it and which outputs receive it. */
@@ -5758,15 +5829,22 @@ declare class ArkadeTransactionBuilder {
         arkTx: Transaction;
         checkpoints: Transaction[];
     }>;
+    private assemble;
     /** Build, submit and return the finalized transaction. */
     send(): Promise<ArkadeSpendResult>;
     /** Sign the client-owned inputs of the ark tx (no-op when there are none). */
     private signArk;
-    /** Indexes of inputs the client owns and must sign (contract input + funded inputs). */
+    /** The functions this spend goes through: the `.from()` ones, else this builder's own. */
+    private unlockers;
+    /** Indexes of inputs the client owns and must sign (contract inputs + funded inputs). */
     private userInputIndexes;
     private selectCoin;
+    /**
+     * Whether input `vin`'s assets are routed: by a `.withAsset()` input, or a caller's asset packet.
+     * A caller's packet counts for every input, unread; arkd checks what it actually routes.
+     */
+    private routesAssetsFrom;
     private buildAssetPacket;
-    private witnessBytes;
 }
 
 /**
@@ -5818,12 +5896,14 @@ declare const index_ArkadeService: typeof ArkadeService;
 type index_ArkadeSpendResult = ArkadeSpendResult;
 type index_ArkadeTransactionBuilder = ArkadeTransactionBuilder;
 declare const index_ArkadeTransactionBuilder: typeof ArkadeTransactionBuilder;
+type index_ArkadeUnlocker = ArkadeUnlocker;
 declare const index_AsmToken: typeof AsmToken;
 type index_AssetSpec = AssetSpec;
 type index_CallableFunctions = CallableFunctions;
 declare const index_CompiledProgramFunction: typeof CompiledProgramFunction;
 type index_ContractArtifact = ContractArtifact;
 type index_ContractFunctions<P extends Program> = ContractFunctions<P>;
+type index_ContractUnlockers<P extends Program> = ContractUnlockers<P>;
 declare const index_InputDef: typeof InputDef;
 declare const index_InputRef: typeof InputRef;
 declare const index_OP: typeof OP;
@@ -5862,7 +5942,7 @@ declare const index_toASM: typeof toASM;
 declare const index_validateProgram: typeof validateProgram;
 declare const index_witnessRefToBytes: typeof witnessRefToBytes;
 declare namespace index {
-  export { index_ARKADE_OP as ARKADE_OP, index_ARKADE_OPCODES as ARKADE_OPCODES, index_ARKADE_OPCODE_NAMES as ARKADE_OPCODE_NAMES, index_ARKADE_OPCODE_VALUES as ARKADE_OPCODE_VALUES, index_ARKADE_OPS as ARKADE_OPS, index_Arkade as Arkade, index_ArkadeArgType as ArkadeArgType, index_ArkadeArgValue as ArkadeArgValue, type index_ArkadeBatchInput as ArkadeBatchInput, type index_ArkadeConnectOptions as ArkadeConnectOptions, type index_ArkadeConnectProviderOptions as ArkadeConnectProviderOptions, type index_ArkadeConnectServiceOptions as ArkadeConnectServiceOptions, index_ArkadeContract as ArkadeContract, type index_ArkadeContractEvent as ArkadeContractEvent, type index_ArkadeContractEventType as ArkadeContractEventType, index_ArkadeContractParams as ArkadeContractParams, type index_ArkadeContractSubscription as ArkadeContractSubscription, type index_ArkadeExtendedCoin as ArkadeExtendedCoin, type index_ArkadeExtendedVirtualCoin as ArkadeExtendedVirtualCoin, index_ArkadeFunction as ArkadeFunction, index_ArkadeParamValue as ArkadeParamValue, index_ArkadeProgramScript as ArkadeProgramScript, index_ArkadeScript as ArkadeScript, type index_ArkadeScriptOP as ArkadeScriptOP, type index_ArkadeScriptType as ArkadeScriptType, index_ArkadeSegment as ArkadeSegment, type index_ArkadeServerProvider as ArkadeServerProvider, index_ArkadeService as ArkadeService, type index_ArkadeSpendResult as ArkadeSpendResult, index_ArkadeTransactionBuilder as ArkadeTransactionBuilder, index_AsmToken as AsmToken, type index_AssetSpec as AssetSpec, bignum as BigNum, type index_CallableFunctions as CallableFunctions, index_CompiledProgramFunction as CompiledProgramFunction, type index_ContractArtifact as ContractArtifact, type index_ContractFunctions as ContractFunctions, index_InputDef as InputDef, index_InputRef as InputRef, index_OP as OP, index_OPCODE_NAMES as OPCODE_NAMES, index_OPCODE_VALUES as OPCODE_VALUES, index_Program as Program, index_ProgramKeys as ProgramKeys, index_ResolvedArkadeService as ResolvedArkadeService, index_SUPPORTED_PROGRAM_VERSION as SUPPORTED_PROGRAM_VERSION, index_Script as Script, index_ScriptType as ScriptType, index_SignerRef as SignerRef, index_TapscriptSegment as TapscriptSegment, index_TweakedSigner as TweakedSigner, index_UnsupportedProgramVersionError as UnsupportedProgramVersionError, type index_Utxo as Utxo, index_WitnessRef as WitnessRef, index_arkadeScriptHash as arkadeScriptHash, index_arkadeWitnessHash as arkadeWitnessHash, index_asmToBytes as asmToBytes, index_bytesToASM as bytesToASM, index_computeArkadeScriptPublicKey as computeArkadeScriptPublicKey, index_createArkadeBatchHandler as createArkadeBatchHandler, index_deserializeArkadeContractParams as deserializeArkadeContractParams, index_fromASM as fromASM, index_getOpcodeName as getOpcodeName, index_getOpcodeValue as getOpcodeValue, index_isContractArtifact as isContractArtifact, index_parseArtifact as parseArtifact, index_programFromArtifact as programFromArtifact, index_resolveArkadeService as resolveArkadeService, index_resolveAsm as resolveAsm, index_serializeArkadeContractParams as serializeArkadeContractParams, index_stringifyArtifact as stringifyArtifact, index_toASM as toASM, index_validateProgram as validateProgram, index_witnessRefToBytes as witnessRefToBytes };
+  export { index_ARKADE_OP as ARKADE_OP, index_ARKADE_OPCODES as ARKADE_OPCODES, index_ARKADE_OPCODE_NAMES as ARKADE_OPCODE_NAMES, index_ARKADE_OPCODE_VALUES as ARKADE_OPCODE_VALUES, index_ARKADE_OPS as ARKADE_OPS, index_Arkade as Arkade, index_ArkadeArgType as ArkadeArgType, index_ArkadeArgValue as ArkadeArgValue, type index_ArkadeBatchInput as ArkadeBatchInput, type index_ArkadeConnectOptions as ArkadeConnectOptions, type index_ArkadeConnectProviderOptions as ArkadeConnectProviderOptions, type index_ArkadeConnectServiceOptions as ArkadeConnectServiceOptions, index_ArkadeContract as ArkadeContract, type index_ArkadeContractEvent as ArkadeContractEvent, type index_ArkadeContractEventType as ArkadeContractEventType, index_ArkadeContractParams as ArkadeContractParams, type index_ArkadeContractSubscription as ArkadeContractSubscription, type index_ArkadeExtendedCoin as ArkadeExtendedCoin, type index_ArkadeExtendedVirtualCoin as ArkadeExtendedVirtualCoin, index_ArkadeFunction as ArkadeFunction, index_ArkadeParamValue as ArkadeParamValue, index_ArkadeProgramScript as ArkadeProgramScript, index_ArkadeScript as ArkadeScript, type index_ArkadeScriptOP as ArkadeScriptOP, type index_ArkadeScriptType as ArkadeScriptType, index_ArkadeSegment as ArkadeSegment, type index_ArkadeServerProvider as ArkadeServerProvider, index_ArkadeService as ArkadeService, type index_ArkadeSpendResult as ArkadeSpendResult, index_ArkadeTransactionBuilder as ArkadeTransactionBuilder, type index_ArkadeUnlocker as ArkadeUnlocker, index_AsmToken as AsmToken, type index_AssetSpec as AssetSpec, bignum as BigNum, type index_CallableFunctions as CallableFunctions, index_CompiledProgramFunction as CompiledProgramFunction, type index_ContractArtifact as ContractArtifact, type index_ContractFunctions as ContractFunctions, type index_ContractUnlockers as ContractUnlockers, index_InputDef as InputDef, index_InputRef as InputRef, index_OP as OP, index_OPCODE_NAMES as OPCODE_NAMES, index_OPCODE_VALUES as OPCODE_VALUES, index_Program as Program, index_ProgramKeys as ProgramKeys, index_ResolvedArkadeService as ResolvedArkadeService, index_SUPPORTED_PROGRAM_VERSION as SUPPORTED_PROGRAM_VERSION, index_Script as Script, index_ScriptType as ScriptType, index_SignerRef as SignerRef, index_TapscriptSegment as TapscriptSegment, index_TweakedSigner as TweakedSigner, index_UnsupportedProgramVersionError as UnsupportedProgramVersionError, type index_Utxo as Utxo, index_WitnessRef as WitnessRef, index_arkadeScriptHash as arkadeScriptHash, index_arkadeWitnessHash as arkadeWitnessHash, index_asmToBytes as asmToBytes, index_bytesToASM as bytesToASM, index_computeArkadeScriptPublicKey as computeArkadeScriptPublicKey, index_createArkadeBatchHandler as createArkadeBatchHandler, index_deserializeArkadeContractParams as deserializeArkadeContractParams, index_fromASM as fromASM, index_getOpcodeName as getOpcodeName, index_getOpcodeValue as getOpcodeValue, index_isContractArtifact as isContractArtifact, index_parseArtifact as parseArtifact, index_programFromArtifact as programFromArtifact, index_resolveArkadeService as resolveArkadeService, index_resolveAsm as resolveAsm, index_serializeArkadeContractParams as serializeArkadeContractParams, index_stringifyArtifact as stringifyArtifact, index_toASM as toASM, index_validateProgram as validateProgram, index_witnessRefToBytes as witnessRefToBytes };
 }
 
 /** Known BIP21 parameters including Arkade-specific extensions. */

package/dist/index.js

@@ -1,6 +1,6 @@
-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, Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports as arkade, assertFinalCommitmentMatchesValidated, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, deleteByIndex, deserializeExitPackage, encodeArkContract, exitObserverFor, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, logExcludedVtxos, makeHandle, matchServerCheckpoints, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeExitPackage, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, submitViaEmulator, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, withPrevTxs } from './chunk-NKKJEA3Z.js';
-export { ChainTxType, DEFAULT_VTXO_PAGE_SIZE, IndexerTxType, RestIndexerProvider, asset_exports as asset } from './chunk-6MIGYYWB.js';
-export { ArkadeContractHandler, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, UnsupportedProgramVersionError, VHTLC, VHTLCContractHandler, VHTLCV2ContractHandler, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, identityDescriptor, isCltvSatisfied, isCsvSpendable, normalizeToDescriptor, parseHDDescriptor, toXOnly } from './chunk-3M22PJVB.js';
-export { ArkAddress, ArkError, ArkErrorName, ArkPsbtFieldKey, ArkPsbtFieldKeyType, BITCOIN_EMULATOR_PUBKEY, CLTVMultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, ConditionWitness, CosignerPublicKey, DEFAULT_ARKADE_EMULATOR_URL, DigestMismatchError, EventSourceUnavailableError, FetchError, Intent, MUTINYNET_EMULATOR_PUBKEY, MultisigTapscript, PrevArkTxField, PrevoutTxField, ProviderUnavailableError, READ_TIMEOUT_MS, REGTEST_EMULATOR_PUBKEY, RestArkProvider, ServerResponseMismatchError, SettlementEventType, TapTreeCoder, Transaction, VtxoScript, VtxoTaprootTree, VtxoTreeExpiry, assembleBtcdTaprootTree, assertAllowedSighashTypes, assertNonNegativeMs, assertTimerMs, buildVersion, canRecoverOnchain, canSpendOffchain, canSweepOnchain, configureEventSource, decodeTapscript, defaultEmulatorPubkey, getAllNormalizedVtxos, getArkPsbtFields, getConfiguredEventSource, getNetwork, getNormalizedVtxos, getSequence, isArkError, isEventSourceUnavailableError, isPastExpiry, isRetryableProviderError, isVirtualCoin, isVtxoSpent, maybeArkError, networkFromArkadeInfo, networks, resolveEmulatorPubkey, resolveEventSource, scriptFromTapLeafScript, sdkVersion, sequenceToTimelock, setArkPsbtField, timelockToSequence, toOffchainInputFeeParams } from './chunk-QFB55EOZ.js';
+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, Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports as arkade, assertFinalCommitmentMatchesValidated, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, deleteByIndex, deserializeExitPackage, encodeArkContract, exitObserverFor, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, logExcludedVtxos, makeHandle, matchServerCheckpoints, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeExitPackage, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, submitViaEmulator, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, withPrevTxs } from './chunk-HAQAWBYG.js';
+export { ChainTxType, DEFAULT_VTXO_PAGE_SIZE, IndexerTxType, RestIndexerProvider, asset_exports as asset } from './chunk-6FL4N4S2.js';
+export { ArkadeContractHandler, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, UnsupportedProgramVersionError, VHTLC, VHTLCContractHandler, VHTLCV2ContractHandler, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, identityDescriptor, isCltvSatisfied, isCsvSpendable, normalizeToDescriptor, parseHDDescriptor, toXOnly } from './chunk-P7B4LQ3H.js';
+export { ArkAddress, ArkError, ArkErrorName, ArkPsbtFieldKey, ArkPsbtFieldKeyType, BITCOIN_EMULATOR_PUBKEY, CLTVMultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, ConditionWitness, CosignerPublicKey, DEFAULT_ARKADE_EMULATOR_URL, DigestMismatchError, EventSourceUnavailableError, FetchError, Intent, MUTINYNET_EMULATOR_PUBKEY, MultisigTapscript, PrevArkTxField, PrevoutTxField, ProviderUnavailableError, READ_TIMEOUT_MS, REGTEST_EMULATOR_PUBKEY, RestArkProvider, ServerResponseMismatchError, SettlementEventType, TapTreeCoder, Transaction, VtxoScript, VtxoTaprootTree, VtxoTreeExpiry, assembleBtcdTaprootTree, assertAllowedSighashTypes, assertNonNegativeMs, assertTimerMs, buildVersion, canRecoverOnchain, canSpendOffchain, canSweepOnchain, configureEventSource, decodeTapscript, defaultEmulatorPubkey, getAllNormalizedVtxos, getArkPsbtFields, getConfiguredEventSource, getNetwork, getNormalizedVtxos, getSequence, isArkError, isEventSourceUnavailableError, isPastExpiry, isRetryableProviderError, isVirtualCoin, isVtxoSpent, maybeArkError, networkFromArkadeInfo, networks, resolveEmulatorPubkey, resolveEventSource, scriptFromTapLeafScript, sdkVersion, sequenceToTimelock, setArkPsbtField, timelockToSequence, toOffchainInputFeeParams } from './chunk-OPX2HRWM.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/repositories/realm/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkQKNSMVBW_cjs = require('../../chunk-QKNSMVBW.cjs');
-require('../../chunk-HQNQ3CLQ.cjs');
-require('../../chunk-GW42FS2X.cjs');
-var chunkXLHUGP3G_cjs = require('../../chunk-XLHUGP3G.cjs');
+var chunkOUTWUYJ4_cjs = require('../../chunk-OUTWUYJ4.cjs');
+require('../../chunk-ZMSM3NOH.cjs');
+require('../../chunk-BYPBVHVA.cjs');
+var chunkKW7ZEWYS_cjs = require('../../chunk-KW7ZEWYS.cjs');
 
 // src/repositories/realm/walletRepository.ts
 var RealmWalletRepository = class {
@@ -35,7 +35,7 @@ var RealmWalletRepository = class {
     await this.ensureInit();
     this.realm.write(() => {
       for (const vtxo of vtxos) {
-        const s = chunkQKNSMVBW_cjs.serializeVtxo(vtxo);
+        const s = chunkOUTWUYJ4_cjs.serializeVtxo(vtxo);
         this.realm.create(
           "ArkVtxo",
           {
@@ -50,7 +50,7 @@ var RealmWalletRepository = class {
             intentCb: s.intentTapLeafScript.cb,
             intentS: s.intentTapLeafScript.s,
             statusJson: JSON.stringify(s.status),
-            createdAt: chunkQKNSMVBW_cjs.createdAtToIso(s.createdAt),
+            createdAt: chunkOUTWUYJ4_cjs.createdAtToIso(s.createdAt),
             isUnrolled: s.isUnrolled ?? false,
             isSpent: s.isSpent === void 0 ? null : s.isSpent,
             isSwept: s.isSwept === void 0 ? null : s.isSwept,
@@ -74,7 +74,7 @@ var RealmWalletRepository = class {
     return this.deleteWhere("ArkVtxo", "address", address);
   }
   async getVtxosForScriptPage(script, page, options) {
-    chunkQKNSMVBW_cjs.assertPageRequest(page);
+    chunkOUTWUYJ4_cjs.assertPageRequest(page);
     await this.ensureInit();
     let results = this.realm.objects("ArkVtxo").filtered("script == $0", script);
     if (options?.unspentOnly) {
@@ -101,15 +101,15 @@ var RealmWalletRepository = class {
       rows.push({ address: row.address, vtxo: vtxoObjectToDomain(row) });
       if (rows.length > page.limit) break;
     }
-    const result = chunkQKNSMVBW_cjs.pageResult(rows, page.limit, (row) => ({
+    const result = chunkOUTWUYJ4_cjs.pageResult(rows, page.limit, (row) => ({
       address: row.address,
       txid: row.vtxo.txid,
       vout: row.vtxo.vout
     }));
-    return options?.unspentOnly ? { ...result, items: result.items.filter((row) => !chunkXLHUGP3G_cjs.isVtxoSpent(row.vtxo)) } : result;
+    return options?.unspentOnly ? { ...result, items: result.items.filter((row) => !chunkKW7ZEWYS_cjs.isVtxoSpent(row.vtxo)) } : result;
   }
   async saveVtxosForScript(key, vtxos) {
-    return this.saveVtxos(chunkQKNSMVBW_cjs.checkSaveVtxosForScript("RealmWalletRepository", key, vtxos), vtxos);
+    return this.saveVtxos(chunkOUTWUYJ4_cjs.checkSaveVtxosForScript("RealmWalletRepository", key, vtxos), vtxos);
   }
   async deleteVtxosForScript(script) {
     return this.deleteWhere("ArkVtxo", "script", script);
@@ -119,7 +119,7 @@ var RealmWalletRepository = class {
     return this.pageByAddress("ArkUtxo", address, page, utxoObjectToDomain);
   }
   async pageByAddress(schema, address, page, deserialize) {
-    chunkQKNSMVBW_cjs.assertPageRequest(page);
+    chunkOUTWUYJ4_cjs.assertPageRequest(page);
     await this.ensureInit();
     let results = this.realm.objects(schema).filtered("address == $0", address);
     if (page.after) {
@@ -137,18 +137,18 @@ var RealmWalletRepository = class {
       rows.push({ key: { txid: row.txid, vout: row.vout }, item: deserialize(row) });
       if (rows.length > page.limit) break;
     }
-    const result = chunkQKNSMVBW_cjs.pageResult(rows, page.limit, (row) => row.key);
+    const result = chunkOUTWUYJ4_cjs.pageResult(rows, page.limit, (row) => row.key);
     return { items: result.items.map((row) => row.item), nextCursor: result.nextCursor };
   }
   async saveUtxos(addressOrBatch, utxos) {
     await this.ensureInit();
-    const rows = chunkQKNSMVBW_cjs.utxoEntries(addressOrBatch, utxos).flatMap(
+    const rows = chunkOUTWUYJ4_cjs.utxoEntries(addressOrBatch, utxos).flatMap(
       ([address, list]) => list.map((utxo) => ({ address, utxo }))
     );
     if (rows.length === 0) return;
     this.realm.write(() => {
       for (const { address, utxo } of rows) {
-        const s = chunkQKNSMVBW_cjs.serializeUtxo(utxo);
+        const s = chunkOUTWUYJ4_cjs.serializeUtxo(utxo);
         this.realm.create(
           "ArkUtxo",
           {
@@ -175,8 +175,8 @@ var RealmWalletRepository = class {
   }
   // ── Transaction history ────────────────────────────────────────────
   async getTransactionHistoryPage(filter, page) {
-    chunkQKNSMVBW_cjs.assertPageRequest(page);
-    chunkQKNSMVBW_cjs.assertHistoryPageFilter(filter);
+    chunkOUTWUYJ4_cjs.assertPageRequest(page);
+    chunkOUTWUYJ4_cjs.assertHistoryPageFilter(filter);
     let results = this.realm.objects("ArkTransaction").filtered("address == $0", filter.address);
     results = results.filtered(
       "createdAt >= $0",
@@ -190,12 +190,12 @@ var RealmWalletRepository = class {
       ["arkTxid", false]
     ])) {
       const tx = txObjectToDomain(row);
-      if (page.after !== void 0 && chunkQKNSMVBW_cjs.compareHistoryCursors({ createdAt: tx.createdAt, key: tx.key }, page.after) <= 0)
+      if (page.after !== void 0 && chunkOUTWUYJ4_cjs.compareHistoryCursors({ createdAt: tx.createdAt, key: tx.key }, page.after) <= 0)
         continue;
       rows.push(tx);
       if (rows.length > page.limit) break;
     }
-    return chunkQKNSMVBW_cjs.pageResult(rows, page.limit, (tx) => ({ createdAt: tx.createdAt, key: tx.key }));
+    return chunkOUTWUYJ4_cjs.pageResult(rows, page.limit, (tx) => ({ createdAt: tx.createdAt, key: tx.key }));
   }
   async saveTransactions(address, txs) {
     await this.ensureInit();
@@ -213,7 +213,7 @@ var RealmWalletRepository = class {
             amount: tx.amount,
             settled: tx.settled,
             createdAt: tx.createdAt,
-            assetsJson: tx.assets ? JSON.stringify(chunkQKNSMVBW_cjs.serializeAssets(tx.assets)) : null
+            assetsJson: tx.assets ? JSON.stringify(chunkOUTWUYJ4_cjs.serializeAssets(tx.assets)) : null
           },
           "modified"
         );
@@ -290,9 +290,9 @@ function vtxoObjectToDomain(obj) {
     // Post-migration every row has `script`, but the backfill is
     // idempotent: derive from `address` if the legacy column is still
     // null (e.g. the migration hasn't run yet on this handle).
-    script: obj.script ?? chunkQKNSMVBW_cjs.scriptFromArkAddress(obj.address)
+    script: obj.script ?? chunkOUTWUYJ4_cjs.scriptFromArkAddress(obj.address)
   };
-  return chunkQKNSMVBW_cjs.deserializeVtxo(serialized);
+  return chunkOUTWUYJ4_cjs.deserializeVtxo(serialized);
 }
 function utxoObjectToDomain(obj) {
   const serialized = {
@@ -311,7 +311,7 @@ function utxoObjectToDomain(obj) {
     status: JSON.parse(obj.statusJson),
     extraWitness: obj.extraWitnessJson ? JSON.parse(obj.extraWitnessJson) : void 0
   };
-  return chunkQKNSMVBW_cjs.deserializeUtxo(serialized);
+  return chunkOUTWUYJ4_cjs.deserializeUtxo(serialized);
 }
 function txObjectToDomain(obj) {
   const tx = {
@@ -326,7 +326,7 @@ function txObjectToDomain(obj) {
     createdAt: obj.createdAt
   };
   if (obj.assetsJson) {
-    tx.assets = chunkQKNSMVBW_cjs.deserializeAssets(JSON.parse(obj.assetsJson));
+    tx.assets = chunkOUTWUYJ4_cjs.deserializeAssets(JSON.parse(obj.assetsJson));
   }
   return tx;
 }
@@ -352,9 +352,9 @@ var RealmContractRepository = class {
   }
   // ── Contract management ────────────────────────────────────────────
   async getContractsPage(filter, page) {
-    chunkQKNSMVBW_cjs.assertPageRequest(page);
-    if (chunkQKNSMVBW_cjs.contractFilterMatchesNothing(filter)) return { items: [] };
-    const toPage = (rows) => chunkQKNSMVBW_cjs.pageResult(rows.map(contractObjectToDomain), page.limit, (contract) => contract.script);
+    chunkOUTWUYJ4_cjs.assertPageRequest(page);
+    if (chunkOUTWUYJ4_cjs.contractFilterMatchesNothing(filter)) return { items: [] };
+    const toPage = (rows) => chunkOUTWUYJ4_cjs.pageResult(rows.map(contractObjectToDomain), page.limit, (contract) => contract.script);
     if (filter?.watch === void 0 || filter.script !== void 0) {
       return toPage(this.readRows(filter, page));
     }
@@ -512,7 +512,7 @@ var RealmIntentRepository = class {
         const clashes = [
           ...this.realm.objects("ArkIntent").filtered("intentId == $0", intent.intentId)
         ].map(toIntent);
-        chunkQKNSMVBW_cjs.assertIntentIdUnique(intent, clashes);
+        chunkOUTWUYJ4_cjs.assertIntentIdUnique(intent, clashes);
       }
       this.realm.create(
         "ArkIntent",
@@ -540,22 +540,22 @@ var RealmIntentRepository = class {
     });
   }
   async getIntentsPage(filter, page) {
-    chunkQKNSMVBW_cjs.assertPageRequest(page);
+    chunkOUTWUYJ4_cjs.assertPageRequest(page);
     let results = this.realm.objects("ArkIntent");
     if (page.after !== void 0) results = results.filtered("intentTxId > $0", page.after);
     const rows = [];
     for (const row of results.sorted("intentTxId")) {
       const intent = toIntent(row);
-      if (filter && !chunkQKNSMVBW_cjs.intentMatchesFilter(intent, filter)) continue;
+      if (filter && !chunkOUTWUYJ4_cjs.intentMatchesFilter(intent, filter)) continue;
       rows.push(intent);
       if (rows.length > page.limit) break;
     }
-    return chunkQKNSMVBW_cjs.pageResult(rows, page.limit, (intent) => intent.intentTxId);
+    return chunkOUTWUYJ4_cjs.pageResult(rows, page.limit, (intent) => intent.intentTxId);
   }
   async getLockedVtxoOutpoints() {
     const out = [];
     for (const o of [...this.realm.objects("ArkIntent")].map(toIntent))
-      if (!chunkQKNSMVBW_cjs.isTerminalIntentState(o.state)) out.push(...o.intentVtxos);
+      if (!chunkOUTWUYJ4_cjs.isTerminalIntentState(o.state)) out.push(...o.intentVtxos);
     return out;
   }
   async [Symbol.asyncDispose]() {
@@ -597,7 +597,7 @@ var RealmVirtualTxRepository = class {
             txid: t.txid,
             psbt: t.psbt ?? prev?.psbt ?? null,
             expiresAt: t.expiresAt ?? prev?.expiresAt ?? null,
-            type: chunkQKNSMVBW_cjs.mergeChainedTxType(t.type, prev?.type)
+            type: chunkOUTWUYJ4_cjs.mergeChainedTxType(t.type, prev?.type)
           },
           "modified"
         );
@@ -842,9 +842,9 @@ function runArkRealmMigrations(oldRealm, newRealm) {
   for (let i = 0; i < newVtxos.length; i++) {
     const newVtxo = newVtxos[i];
     if (!newVtxo.script) {
-      newVtxo.script = chunkQKNSMVBW_cjs.scriptFromArkAddress(newVtxo.address);
+      newVtxo.script = chunkOUTWUYJ4_cjs.scriptFromArkAddress(newVtxo.address);
     }
-    const facts = chunkQKNSMVBW_cjs.legacyVtxoFacts(legacyByPk.get(newVtxo.pk));
+    const facts = chunkOUTWUYJ4_cjs.legacyVtxoFacts(legacyByPk.get(newVtxo.pk));
     if (facts) {
       if (newVtxo.isSpent == null) newVtxo.isSpent = facts.isSpent;
       if (newVtxo.isSwept == null) newVtxo.isSwept = facts.isSwept;
@@ -874,7 +874,7 @@ function runArkRealmMigrations(oldRealm, newRealm) {
 
 Object.defineProperty(exports, "ChainedTxType", {
   enumerable: true,
-  get: function () { return chunkQKNSMVBW_cjs.ChainedTxType; }
+  get: function () { return chunkOUTWUYJ4_cjs.ChainedTxType; }
 });
 exports.ARK_REALM_SCHEMA_VERSION = ARK_REALM_SCHEMA_VERSION;
 exports.ArkExperimentalRealmSchemas = ArkExperimentalRealmSchemas;

package/dist/repositories/realm/index.d.cts

@@ -1,5 +1,5 @@
-import { W as WalletRepository, P as PageRequest, O as Outpoint, F as PageResult, D as ExtendedVirtualCoin, H as ScriptVtxoCursor, J as ScriptVtxoPageOptions, K as StoredVtxo, L as VtxoRepositoryKey, E as ExtendedCoin, M as TransactionHistoryPageFilter, Q as TransactionHistoryPageCursor, h as ArkTransaction, U as WalletState, C as ContractRepository, X as ContractFilter, B as Contract, Y as IntentRepository, Z as ArkIntent, _ as IntentPageFilter, $ as VirtualTxRepository, a0 as VirtualTx, a1 as VtxoBranch } from '../../index-B3fRWO5i.cjs';
-export { a2 as ChainedTxType } from '../../index-B3fRWO5i.cjs';
+import { W as WalletRepository, P as PageRequest, O as Outpoint, F as PageResult, D as ExtendedVirtualCoin, H as ScriptVtxoCursor, J as ScriptVtxoPageOptions, K as StoredVtxo, L as VtxoRepositoryKey, E as ExtendedCoin, M as TransactionHistoryPageFilter, Q as TransactionHistoryPageCursor, h as ArkTransaction, U as WalletState, C as ContractRepository, X as ContractFilter, B as Contract, Y as IntentRepository, Z as ArkIntent, _ as IntentPageFilter, $ as VirtualTxRepository, a0 as VirtualTx, a1 as VtxoBranch } from '../../index-BURzbRup.cjs';
+export { a2 as ChainedTxType } from '../../index-BURzbRup.cjs';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/psbt.js';
 import '@scure/btc-signer';