@arkade-os/sdk 0.5.2 → 0.5.4

package/README.md

@@ -1,6 +1,6 @@
 # Arkade TypeScript SDK
 
-The Arkade SDK is a TypeScript library for building Bitcoin wallets using the Arkade protocol.
+The Arkade SDK is a TypeScript library for building Bitcoin wallets using Arkade.
 
 [![TypeDoc](https://img.shields.io/badge/TypeScript-Documentation-blue?style=flat-square)](https://arkade-os.github.io/ts-sdk/)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/arkade-os/ts-sdk)
@@ -32,7 +32,7 @@ const wallet = await Wallet.create({ identity })  // defaults to mainnet
 ```
 
 `Wallet.create` also accepts short spellings: `service` in place of the
-`arkProvider`/`indexerProvider`/`onchainProvider` trio, `mode` for `walletMode` and
+`operatorProvider`/`indexerProvider`/`onchainProvider` trio, `mode` for `walletMode` and
 `settlement` for `settlementConfig`. Setting both spellings of one field throws.
 
 ### Read-Only Wallets (Watch-Only)
@@ -183,6 +183,8 @@ const balance = await readonlyWallet.getBalance()
 - Coin type 0 for mainnet, 1 for testnet
 - Account 0, external chain, wildcard index — `identity.descriptor` is the wildcard template that drives HD rotation; consumers materialize a concrete descriptor at a specific index when they need one.
 
+For custom `Identity` implementations, see [`TreeSignerSession`](./src/tree/signingSession.ts).
+
 ### Batch Signing for Browser Wallets
 
 Arkade send transactions require N+1 PSBT signatures (N checkpoints + 1 main tx). With local identities like `SingleKey` or `SeedIdentity` this is invisible, but browser wallet extensions (Xverse, UniSat, OKX, etc.) show a confirmation popup per signature. The `BatchSignableIdentity` interface lets wallet providers reduce N+1 popups to a single batch confirmation.
@@ -220,28 +222,28 @@ await wallet.send({ address: 'ark1q...', amount: 1000 })
 
 Identities without `signMultiple` continue to work unchanged — each checkpoint is signed individually via `sign()`.
 
-### Ark Provider Caching
+### Operator Provider Caching
 
-`RestArkProvider.getInfo()` fetches current Arkade server parameters on every call. Wrap it
-with `CachingArkProvider` when you reuse that response for fee, signer, or limit lookups:
+`RestOperatorProvider.getInfo()` fetches current operator parameters on every call. Wrap it
+with `CachingOperatorProvider` when you reuse that response for fee, signer, or limit lookups:
 
 ```typescript
-import { CachingArkProvider, RestArkProvider, Wallet } from '@arkade-os/sdk'
+import { CachingOperatorProvider, RestOperatorProvider, Wallet } from '@arkade-os/sdk'
 
-const arkProvider = new CachingArkProvider(
-  new RestArkProvider('https://arkade.computer'),
+const operatorProvider = new CachingOperatorProvider(
+  new RestOperatorProvider('https://arkade.computer'),
   60_000, // optional TTL in milliseconds; defaults to 60 seconds
 )
 
-const wallet = await Wallet.create({ identity, arkProvider })
+const wallet = await Wallet.create({ identity, operatorProvider })
 ```
 
-Only `getInfo()` is cached; all other Ark provider methods pass through. The cache expires
-after the TTL and updates when the inner provider reports server-info changes, including
-signer rotation. Wrapping `RestArkProvider` preserves its `serverUrl`, so `Wallet.create`
+Only `getInfo()` is cached; all other provider methods pass through. The cache expires
+after the TTL and updates when the inner provider reports operator info changes, including
+signer rotation. Wrapping `RestOperatorProvider` preserves its `serverUrl`, so `Wallet.create`
 can still derive the default indexer URL. Expired refresh failures propagate;
 wallet boot fallback lives in the persisted ArkInfo snapshot. Call `dispose()` if the
-inner provider outlives the wrapper, to drop its server-info subscription.
+inner provider outlives the wrapper, to drop its operator info subscription.
 
 ### Onchain Providers
 
@@ -415,7 +417,7 @@ const balance = await wallet.getBalance()
 | `pendingSettlement` | Committed to an in-flight settlement intent; back in `available` when the intent ends. Always `0` without `storage.intentRepository`. |
 | `reserved` | Held by [`reserveVtxos`](#holding-vtxos-for-your-own-use) until released. |
 | `recoverable` | Swept or subdust virtual outputs that [`recoverVtxos`](#recovery-reclaim-swept-vtxos) can reclaim; `getRecoverableBalance()` gives what a batch would return today. |
-| `deprecatedSignerLocked` | Under a server signer past its cutoff, which the operator no longer co-signs; recovers once swept and re-settled. |
+| `deprecatedSignerLocked` | Under an operator signer past its cutoff, which the operator no longer cosigns; recovers once swept and re-settled. |
 | `unrolled` | Already [unilaterally exited](#unilateral-exit): onchain behind its CSV timelock, movable only by `Unroll.completeUnroll`. |
 | `total` | Everything the wallet owns: `boarding.total + settled + preconfirmed + recoverable + deprecatedSignerLocked + unrolled`. |
 | `assets` | Every [asset](#assets-issue-reissue-burn-send) balance the wallet owns. |
@@ -651,7 +653,7 @@ try {
 
 #### Recovery: Reclaim Swept VTXOs
 
-Recover virtual outputs that have been swept by the server or consolidate small amounts (subdust).
+Recover virtual outputs that have been swept by the operator or consolidate small amounts (subdust).
 
 ```typescript
 // Recover swept virtual outputs and preconfirmed subdust
@@ -672,7 +674,7 @@ Instead of the delegating user renewing virtual outputs by themselves, their del
 
 This is useful for wallets that cannot be online 24/7.
 
-When a `delegateProvider` is configured, the wallet address includes an extra tapscript path that authorizes the delegate to co-sign renewals alongside the Arkade server.
+When a `delegateProvider` is configured, the wallet address includes an extra tapscript path that authorizes the delegate to cosign renewals alongside the operator.
 
 To run a delegation service, you'll need to set up a [Fulmine server](https://github.com/ArkLabsHQ/fulmine) with the [Delegation API](https://github.com/ArkLabsHQ/fulmine?tab=readme-ov-file#-delegate-api) enabled.
 
@@ -822,7 +824,7 @@ exit waits for its batch swap queues until that batch swap finalizes, and an exi
 spends every spendable VTXO. Opt in to let spends overlap on disjoint VTXOs:
 
 ```typescript
-const wallet = await Wallet.create({ identity, arkProvider, concurrentSpending: true })
+const wallet = await Wallet.create({ identity, operatorProvider, concurrentSpending: true })
 ```
 
 With `concurrentSpending`:
@@ -870,7 +872,7 @@ Limits:
 - Deprecated-signer migration and recovery name the VTXOs they move, so they can spend a held VTXO.
 - Renewal skips a held VTXO even once it is inside the renewal threshold, since renewing would
   change the outpoint you are holding. It logs a warning naming each such VTXO; spend or release a
-  long-lived hold before the VTXO expires, or the server sweeps it and it comes back only through
+  long-lived hold before the VTXO expires, or the operator sweeps it and it comes back only through
   recovery.
 - `toReadonly()` views and the service worker's balance reads do not see reservations.
 - `reserveVtxos` is on `Wallet`; the service-worker and Expo wallets accept `concurrentSpending`
@@ -880,7 +882,7 @@ If your app keeps its own reserved-outpoint set, call `reserveVtxos` where you a
 `release()` where you remove, then let the SDK pick: plain `send`, router payments without
 `selectedVtxos`, and exits without `vtxos` all skip what you hold.
 
-### Talking to the server through the wallet
+### Talking to the operator through the wallet
 
 `getArkadeInfo()` is one of three seams that let a plugin work from a wallet alone, never a
 server URL of its own:
@@ -897,7 +899,7 @@ const { vtxos } = await reader.getVtxos({ scripts: [covenantScriptHex], spendabl
 const { txs } = await reader.getVirtualTxs([spendTxid]);
 ```
 
-`getVtxos()` here queries the server for an arbitrary script — distinct from
+`getVtxos()` here queries the operator for an arbitrary script — distinct from
 `wallet.getVtxos()`, which answers the wallet's own outputs from local repositories. Everything
 it returns is normalized, so each VTXO carries its canonical facts.
 
@@ -909,7 +911,7 @@ connection instead of opening a second one outside its rate gate and caches.
 
 ### Unilateral Exit
 
-Unilateral exit allows you to withdraw your funds from the Arkade protocol back to the Bitcoin blockchain without requiring cooperation from the Arkade server. This process involves two main steps:
+Unilateral exit lets you move your funds from virtual outputs to onchain outputs without cooperation from the operator. This process involves two main steps:
 
 1. **Unrolling**: Broadcasting the transaction chain from offchain back to onchain
 2. **Completing the exit**: Spending the unrolled virtual outputs after the timelock expires
@@ -1085,7 +1087,7 @@ Key properties:
 
 ### Exit data available offline
 
-The exit above resolves a VTXO's transaction chain from the Ark **indexer** at
+The exit above resolves a VTXO's transaction chain from the Arkade **indexer** at
 exit time. To make a unilateral exit work even when the indexer is unreachable,
 configure a `virtualTxRepository` (SQLite / Realm / IndexedDB / InMemory): the
 wallet then captures each received VTXO's exit branch locally and prunes it on
@@ -1103,7 +1105,7 @@ const wallet = await Wallet.create({
     virtualTxRepository: new InMemoryVirtualTxRepository(),
     // Optional. `mode` defaults to "lite" (structure only, cheap — most VTXOs
     // never exit). Use "full" to also store the pre-signed PSBTs, so an exit
-    // needs no Ark indexer (only an Esplora endpoint to broadcast).
+    // needs no Arkade indexer (only an Esplora endpoint to broadcast).
     exitDataCapture: { mode: 'full' },
   },
 })
@@ -1193,7 +1195,7 @@ display after completion; cached reads do not guarantee a change event.
 `getStoredBalance().boarding.loaded` is false until this wallet instance has fetched
 boarding inputs. Call `getBoardingUtxos()` to refresh them. Stored methods are for
 display, not transaction inputs; use the normal reads and spending APIs for actions.
-New contract registration, identity setup, and server-info validation can still
+New contract registration, identity setup, and operator info validation can still
 require provider calls even with lazy initialization enabled.
 
 Service-worker factories expose the same `lazyInitialization` option and a separate
@@ -1415,13 +1417,13 @@ For React Native and Expo applications where standard EventSource and fetch stre
 
 ```typescript
 import { Wallet, MnemonicIdentity } from '@arkade-os/sdk'
-import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo'
+import { ExpoOperatorProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo'
 
 const identity = MnemonicIdentity.fromMnemonic('abandon abandon...')
 
 const wallet = await Wallet.create({
   identity: identity,
-  arkProvider: new ExpoArkProvider('https://arkade.computer'), // For settlement events and transactions streaming
+  operatorProvider: new ExpoOperatorProvider('https://arkade.computer'), // For settlement events and transactions streaming
   indexerProvider: new ExpoIndexerProvider('https://arkade.computer'), // For address subscriptions and virtual output state updates
 })
 
@@ -1431,9 +1433,9 @@ const balance = await wallet.getBalance()
 const address = await wallet.getAddress()
 ```
 
-Both ExpoArkProvider and ExpoIndexerProvider are available as adapters following the SDK's modular architecture pattern. This keeps the main SDK bundle clean while providing opt-in functionality for specific environments:
+Both ExpoOperatorProvider and ExpoIndexerProvider are available as adapters following the SDK's modular architecture pattern. This keeps the main SDK bundle clean while providing opt-in functionality for specific environments:
 
-- **ExpoArkProvider**: Handles settlement events and transaction streaming using expo/fetch for Server-Sent Events
+- **ExpoOperatorProvider**: Handles settlement events and transaction streaming using expo/fetch for Server-Sent Events
 - **ExpoIndexerProvider**: Handles address subscriptions and virtual output state updates using expo/fetch for JSON streaming
 
 For persistence in Expo/React Native, use the SQLite repository with `expo-sqlite`:
@@ -1451,7 +1453,7 @@ const executor = {
 
 const wallet = await Wallet.create({
   identity,
-  arkProvider: new ExpoArkProvider('https://arkade.computer'),
+  operatorProvider: new ExpoOperatorProvider('https://arkade.computer'),
   indexerProvider: new ExpoIndexerProvider('https://arkade.computer'),
   storage: {
     walletRepository: new SQLiteWalletRepository(executor),
@@ -1476,7 +1478,7 @@ global.crypto.getRandomValues = Crypto.getRandomValues;
 
 // Now import the SDK
 import { Wallet, MnemonicIdentity } from '@arkade-os/sdk';
-import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo';
+import { ExpoOperatorProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo';
 ```
 
 This is required for MuSig2 settlements and cryptographic operations.
@@ -1495,7 +1497,7 @@ To watch transactions at scripts you don't know in advance (extension packets at
 
 Read compiler format v1 JSON with `arkade.programFromArtifact`, which returns a normalized Program at version 1. `arkade.parseArtifact` reads normalized Program JSON and defaults omitted versions to 1. Only version 1 is supported, with typed `{ name, type }` declarations for every constructor parameter and call argument. Explicit version 0 programs, including persisted contracts, are rejected; there is no automatic migration. Older SDKs reject version 1 programs rather than silently reconstructing a different script. An Arkade function and its same-named Taproot leaf share one call, such as `contract.functions.claim(...)`. Standalone Taproot functions use their own names, such as `contract.functions.unilateral()`. Leaf order in the artifact still determines the Taproot tree. This example assumes a `digest: bytes32` constructor and a `claim` function with one `preimage: bytes32` covenant argument; wallet, artifact JSON and matching digest/preimage values are already available.
 
-Declarations retain the compiler's native scalar names: `pubkey`, `signature`, `bytes`, `bytes20`, `bytes32`, `asset`, `int`, `bool` and `AssetGroup`. There are no `hash` or `sig` type aliases. Byte types take `Uint8Array`; `int`, `bool` and `AssetGroup` take `bigint | number`, with `bool` restricted to `0` or `1`. Fixed widths follow the type itself, without extra width or boolean flags. The SDK requires every `pubkey` to be a 32-byte x-only key, although the language treats it as a bytes alias. Structs and arrays retain the compiler's flattened scalar field names and ordering.
+Declarations retain the compiler's native scalar names: `pubkey`, `signature`, `bytes`, `bytes20`, `bytes32`, `asset`, `int`, `bool` and `AssetGroup`. There are no `hash` or `sig` type aliases. Byte types take `Uint8Array`; `int`, `bool` and `AssetGroup` take `bigint | number`, with `bool` restricted to `0` or `1`. Fixed widths follow the type itself, without extra width or boolean flags. The SDK requires every `pubkey` to be a 32-byte x-only key, although the language treats it as a bytes alias. Structs and arrays retain the compiler's flattened scalar field names and ordering in the normalized Program, but deployments and calls take them whole: an object for a struct, an array for a fixed array, nested to any depth.
 
 The normalized Program remains an SDK representation: compiler `constructorInputs` become `params`, spend groups and leaves become named `functions`, and covenant `arkade` becomes `arkadeScript`. `parseArtifact` and `stringifyArtifact` read and write that normalized representation; `programFromArtifact` reads the compiler format. Existing deployment and call methods use the same syntax for imported and hand-written programs.
 
@@ -1506,7 +1508,7 @@ import { arkade, Arkade, ArkAddress } from '@arkade-os/sdk'
 
 const program = arkade.programFromArtifact(artifactJson)
 const client = await Arkade.connect({
-  service: { network: 'bitcoin' }, // operator, indexer, esplora and covenant co-signer
+  service: { network: 'bitcoin' }, // operator, indexer, esplora, and covenant cosigner
   identity: wallet.identity,
   contractManager: await wallet.getContractManager(),
 })
@@ -1526,9 +1528,9 @@ await wallet.send({ address: contract.address, amount: 10_000 })
 
 `contract.on('vtxo_received' | 'vtxo_spent' | 'connection_reset', cb)` reports activity from subscription on and returns a handle with `off()`. Coins that predate it are not replayed and a reconnect re-syncs silently, so read `contract.getVtxos()` (every stored VTXO, spent ones included) after subscribing and on each `connection_reset`.
 
-The connected server supplies `<SERVER_KEY>` (the reserved `server` parameter in normalized Programs) and `<SERVER_EXIT_DELAY>`; conflicting overrides fail, and time-based delays that are not multiples of 512 seconds fail rather than changing the advertised delay. Resolved bindings are persisted, so restoring the contract keeps its script through server key or policy changes. A declared constructor named `user` defaults to the connected identity; other constructor keys and flattened struct/array fields remain caller-provided, using names such as `owners.0.key`. Child-output placeholders remain explicit `bytes32` constructor bindings. Leaf call inputs used as script operands cannot produce a fixed address and are rejected; raw CSV operands must be canonical BIP68 encodings.
+The connected operator supplies `<SERVER_KEY>` (the reserved `server` parameter in normalized Programs) and `<SERVER_EXIT_DELAY>`; conflicting overrides fail, and time-based delays that are not multiples of 512 seconds fail rather than changing the advertised delay. Resolved bindings are persisted, so restoring the contract keeps its script through server key or policy changes. A declared constructor named `user` defaults to the connected identity; other constructor keys remain caller-provided. Pass a struct or array param whole by its source name, such as `{ owners: [{ key }, { key }] }`; the flattened names it binds, such as `owners.0.key`, are also accepted, and a missing, extra or duplicated field fails with its full name. Child-output placeholders remain explicit `bytes32` constructor bindings. Leaf call inputs used as script operands cannot produce a fixed address and are rejected; raw CSV operands must be canonical BIP68 encodings.
 
-For compiler-derived programs, call arguments are covenant inputs in declaration order, followed by non-signature leaf inputs in declaration order. Same-named inputs in the two scopes remain separate positional arguments. Leaf signatures are PSBT signatures, not condition arguments: `send()` supports the connected identity and infrastructure signers; additional identities and covenant-tweaked leaf keys require explicit PSBT signing via `build()`. Covenant signature arguments remain caller-provided; transaction-bound Arkade `checkSig` signatures require an Arkade-specific digest helper, which is deferred. CSV leaves require aged onchain outputs and cannot use this offchain builder. Typed call validation and these spending limits apply to every normalized Program. The public `SignerRef` union is unchanged; version 1 programs store emulator signer placement in optional `emulatorIndex` metadata.
+For compiler-derived programs, call arguments are covenant inputs in declaration order, followed by non-signature leaf inputs in declaration order, one argument per source parameter: a struct or array input is passed whole, as in `contract.functions.spend(request, oracles)`. Same-named inputs in the two scopes remain separate positional arguments. Leaf signatures are PSBT signatures, not condition arguments: `send()` supports the connected identity and infrastructure signers; additional identities and covenant-tweaked leaf keys require explicit PSBT signing via `build()`. Covenant signature arguments remain caller-provided; transaction-bound Arkade `checkSig` signatures require an Arkade-specific digest helper, which is deferred. CSV leaves require aged onchain outputs and cannot use this offchain builder. Typed call validation and these spending limits apply to every normalized Program. The public `SignerRef` union is unchanged; version 1 programs store emulator signer placement in optional `emulatorIndex` metadata.
 
 #### HD look-ahead window
 

package/dist/adapters/expo.cjs

@@ -1,18 +1,22 @@
 'use strict';
 
-var chunkTAIWH3HG_cjs = require('../chunk-TAIWH3HG.cjs');
-require('../chunk-64R7CRKN.cjs');
-require('../chunk-GGKR4O5X.cjs');
+var chunkDNITZVNG_cjs = require('../chunk-DNITZVNG.cjs');
+require('../chunk-WXNSISXK.cjs');
+require('../chunk-GHUUT54D.cjs');
 
 
 
 Object.defineProperty(exports, "ExpoArkProvider", {
   enumerable: true,
-  get: function () { return chunkTAIWH3HG_cjs.ExpoArkProvider; }
+  get: function () { return chunkDNITZVNG_cjs.ExpoArkProvider; }
 });
 Object.defineProperty(exports, "ExpoIndexerProvider", {
   enumerable: true,
-  get: function () { return chunkTAIWH3HG_cjs.ExpoIndexerProvider; }
+  get: function () { return chunkDNITZVNG_cjs.ExpoIndexerProvider; }
+});
+Object.defineProperty(exports, "ExpoOperatorProvider", {
+  enumerable: true,
+  get: function () { return chunkDNITZVNG_cjs.ExpoOperatorProvider; }
 });
 //# sourceMappingURL=expo.cjs.map
 //# sourceMappingURL=expo.cjs.map

package/dist/adapters/expo.d.cts

@@ -1,28 +1,32 @@
-import { r as RestArkProvider, o as SettlementEvent, T as TxNotificationEvent, s as RestIndexerProvider, t as SubscriptionEvent, u as SubscriptionHeartbeat } from '../index-DdKxfC29.cjs';
-export { v as ArkProvider, w as IndexerProvider } from '../index-DdKxfC29.cjs';
+import { r as RestOperatorProvider, o as SettlementEvent, T as TxNotificationEvent, s as RestIndexerProvider, t as SubscriptionEvent, u as SubscriptionHeartbeat } from '../index-DRwe0UDN.cjs';
+export { v as ArkProvider, w as IndexerProvider, O as OperatorProvider } from '../index-DRwe0UDN.cjs';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/psbt.js';
 import '@scure/btc-signer';
 import '@scure/btc-signer/transaction.js';
 
 /**
- * Expo-compatible Arkade provider implementation using expo/fetch for SSE support.
+ * Expo-compatible operator provider implementation using expo/fetch for SSE support.
  * This provider works specifically in React Native/Expo environments where
  * standard EventSource is not available but expo/fetch provides SSE capabilities.
  *
  * @example
  * ```typescript
- * import { ExpoArkProvider } from '@arkade-os/sdk/providers/expo';
+ * import { ExpoOperatorProvider } from '@arkade-os/sdk/adapters/expo';
  *
- * const provider = new ExpoArkProvider('https://arkade.computer');
+ * const provider = new ExpoOperatorProvider('https://arkade.computer');
  * const info = await provider.getInfo();
  * ```
  */
-declare class ExpoArkProvider extends RestArkProvider {
+declare class ExpoOperatorProvider extends RestOperatorProvider {
     constructor(serverUrl?: string);
     getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
     getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<TxNotificationEvent>;
 }
+/** @deprecated Use {@link ExpoOperatorProvider}. */
+declare const ExpoArkProvider: typeof ExpoOperatorProvider;
+/** @deprecated Use {@link ExpoOperatorProvider}. */
+type ExpoArkProvider = ExpoOperatorProvider;
 
 /**
  * Expo-compatible Indexer provider implementation using expo/fetch for streaming support.
@@ -42,4 +46,4 @@ declare class ExpoIndexerProvider extends RestIndexerProvider {
     protected subscriptionStream(url: string, abortSignal: AbortSignal): AsyncIterableIterator<SubscriptionEvent | SubscriptionHeartbeat>;
 }
 
-export { ExpoArkProvider, ExpoIndexerProvider };
+export { ExpoArkProvider, ExpoIndexerProvider, ExpoOperatorProvider };

package/dist/adapters/expo.d.ts

@@ -1,28 +1,32 @@
-import { r as RestArkProvider, o as SettlementEvent, T as TxNotificationEvent, s as RestIndexerProvider, t as SubscriptionEvent, u as SubscriptionHeartbeat } from '../index-DdKxfC29.js';
-export { v as ArkProvider, w as IndexerProvider } from '../index-DdKxfC29.js';
+import { r as RestOperatorProvider, o as SettlementEvent, T as TxNotificationEvent, s as RestIndexerProvider, t as SubscriptionEvent, u as SubscriptionHeartbeat } from '../index-DRwe0UDN.js';
+export { v as ArkProvider, w as IndexerProvider, O as OperatorProvider } from '../index-DRwe0UDN.js';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/psbt.js';
 import '@scure/btc-signer';
 import '@scure/btc-signer/transaction.js';
 
 /**
- * Expo-compatible Arkade provider implementation using expo/fetch for SSE support.
+ * Expo-compatible operator provider implementation using expo/fetch for SSE support.
  * This provider works specifically in React Native/Expo environments where
  * standard EventSource is not available but expo/fetch provides SSE capabilities.
  *
  * @example
  * ```typescript
- * import { ExpoArkProvider } from '@arkade-os/sdk/providers/expo';
+ * import { ExpoOperatorProvider } from '@arkade-os/sdk/adapters/expo';
  *
- * const provider = new ExpoArkProvider('https://arkade.computer');
+ * const provider = new ExpoOperatorProvider('https://arkade.computer');
  * const info = await provider.getInfo();
  * ```
  */
-declare class ExpoArkProvider extends RestArkProvider {
+declare class ExpoOperatorProvider extends RestOperatorProvider {
     constructor(serverUrl?: string);
     getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
     getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<TxNotificationEvent>;
 }
+/** @deprecated Use {@link ExpoOperatorProvider}. */
+declare const ExpoArkProvider: typeof ExpoOperatorProvider;
+/** @deprecated Use {@link ExpoOperatorProvider}. */
+type ExpoArkProvider = ExpoOperatorProvider;
 
 /**
  * Expo-compatible Indexer provider implementation using expo/fetch for streaming support.
@@ -42,4 +46,4 @@ declare class ExpoIndexerProvider extends RestIndexerProvider {
     protected subscriptionStream(url: string, abortSignal: AbortSignal): AsyncIterableIterator<SubscriptionEvent | SubscriptionHeartbeat>;
 }
 
-export { ExpoArkProvider, ExpoIndexerProvider };
+export { ExpoArkProvider, ExpoIndexerProvider, ExpoOperatorProvider };

package/dist/adapters/expo.js

@@ -1,5 +1,5 @@
-export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-2QRUQXLS.js';
-import '../chunk-U5XG7SWA.js';
-import '../chunk-HKG26NUT.js';
+export { ExpoArkProvider, ExpoIndexerProvider, ExpoOperatorProvider } from '../chunk-TUOLZBNC.js';
+import '../chunk-BTRCN4JJ.js';
+import '../chunk-AG4TFD6F.js';
 //# sourceMappingURL=expo.js.map
 //# sourceMappingURL=expo.js.map

package/dist/{asyncStorageTaskQueue-DIn7bTqN.d.ts → asyncStorageTaskQueue-DHMIxY04.d.ts}

@@ -1,4 +1,4 @@
-import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-ZyGGjtIq.js';
+import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-CDlNeth0.js';
 
 /**
  * Minimal async key-value storage interface.
@@ -46,4 +46,4 @@ declare class AsyncStorageTaskQueue implements TaskQueue {
     private writeList;
 }
 
-export { AsyncStorageTaskQueue as A, type AsyncStorageLike as a };
+export { type AsyncStorageLike as A, AsyncStorageTaskQueue as a };

package/dist/{asyncStorageTaskQueue-BtEc3Qca.d.cts → asyncStorageTaskQueue-DTBa8EH7.d.cts}

@@ -1,4 +1,4 @@
-import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-67YSEpsz.cjs';
+import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-BPPU-YHG.cjs';
 
 /**
  * Minimal async key-value storage interface.
@@ -46,4 +46,4 @@ declare class AsyncStorageTaskQueue implements TaskQueue {
     private writeList;
 }
 
-export { AsyncStorageTaskQueue as A, type AsyncStorageLike as a };
+export { type AsyncStorageLike as A, AsyncStorageTaskQueue as a };

package/dist/{chunk-LWRMSC4M.js → chunk-6CUP6ZIF.js}

@@ -1,4 +1,4 @@
-import { __export, VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE, sequenceToCanonicalTimelock } from './chunk-HKG26NUT.js';
+import { __export, VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE, sequenceToCanonicalTimelock } from './chunk-AG4TFD6F.js';
 import { hex } from '@scure/base';
 import { networks, expand } from '@bitcoinerlab/descriptors-scure';
 import { ScriptNum, OP, Script } from '@scure/btc-signer';
@@ -1539,7 +1539,7 @@ var VHTLCV2ContractHandler = {
     }
     if (claim && refund && hex.encode(claim.emulatorPubkey) !== hex.encode(refund.emulatorPubkey)) {
       throw new Error(
-        "emulator covenant params name two different emulator pubkeys: the suite derives both covenant cosigners from ONE key, so this row cannot be rebuilt as a group"
+        "emulator covenant params name two different emulator pubkeys: the suite derives both covenants from ONE key, so this row cannot be rebuilt as a group"
       );
     }
     if (params.assetTxid === void 0 !== (params.assetGroupIndex === void 0)) {
@@ -2312,5 +2312,5 @@ contractHandlers.register(BoardingContractHandler);
 contractHandlers.register(ArkadeContractHandler);
 
 export { ARKADE_OP, ARKADE_OPCODES, ARKADE_OPCODE_NAMES, ARKADE_OPCODE_VALUES, ARKADE_OPS, ARKADE_TYPE_ENCODINGS, ArkadeContractHandler, ArkadeProgramScript, ArkadeScript, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, OPCODE_NAMES, OPCODE_VALUES, SUPPORTED_PROGRAM_VERSION, UnsupportedProgramVersionError, VHTLC, VHTLCContractHandler, VHTLCV2ContractHandler, WALLET_RECEIVE_SOURCE, arkadeScriptHash, arkadeWitnessHash, asmToBytes, bignum_exports, bytesToASM, computeArkadeScriptPublicKey, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, descriptorIsOurs, deserializeArkadeContractParams, extractPubKey, fromASM, getOpcodeName, getOpcodeValue, identityDescriptor, isCltvSatisfied, isCsvSpendable, isMainnetDescriptor, normalizeToDescriptor, parseArtifact, parseHDDescriptor, resolveAsm, serializeArkadeContractParams, speculativeReceiveMetadata, stringifyArtifact, toASM, toXOnly, validateParamValue, validateProgram, witnessRefToBytes };
-//# sourceMappingURL=chunk-LWRMSC4M.js.map
-//# sourceMappingURL=chunk-LWRMSC4M.js.map
+//# sourceMappingURL=chunk-6CUP6ZIF.js.map
+//# sourceMappingURL=chunk-6CUP6ZIF.js.map