@dynamic-labs-wallet/node-midnight 1.1.3 → 1.1.5

package/index.esm.js

@@ -1,6 +1,13 @@
-import { createLogError, DynamicWalletClient, getMPCChainConfig } from '@dynamic-labs-wallet/node';
+import { createHash } from 'node:crypto';
+import { inspect } from 'node:util';
+import { createLogError, DynamicWalletClient, getMPCChainConfig, WalletOperation } from '@dynamic-labs-wallet/node';
 import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { MidnightBech32m, ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey, DustAddress, mainnet } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { NoOpTransactionHistoryStorage } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { MidnightBech32m, ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey, DustAddress, mainnet, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { DustWallet } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
+import { ShieldedWallet } from '@midnight-ntwrk/wallet-sdk-shielded';
+import { createKeystore, UnshieldedWallet, PublicKey } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
 import { HDKey } from '@scure/bip32';
 import { bech32m } from 'bech32';
 
@@ -16,14 +23,64 @@ var MIDNIGHT_NETWORK_IDS = {
     preprod: 0,
     undeployed: 0
 };
+var _process_env_MIDNIGHT_PROOF_SERVER_URL;
+var MIDNIGHT_PROOF_SERVER_URL = (_process_env_MIDNIGHT_PROOF_SERVER_URL = process.env.MIDNIGHT_PROOF_SERVER_URL) !== null && _process_env_MIDNIGHT_PROOF_SERVER_URL !== void 0 ? _process_env_MIDNIGHT_PROOF_SERVER_URL : 'https://proof-server.us-east-1.dynamic-preprod.xyz';
+/**
+ * Per-network wallet-facade infrastructure. There is no public mainnet proof
+ * server, so Dynamic's is shared across networks for now.
+ */ var MIDNIGHT_INFRA = {
+    mainnet: {
+        relayUrl: 'wss://rpc.mainnet.midnight.network',
+        provingServerUrl: MIDNIGHT_PROOF_SERVER_URL,
+        indexerHttpUrl: 'https://indexer.mainnet.midnight.network/api/v4/graphql',
+        indexerWsUrl: 'wss://indexer.mainnet.midnight.network/api/v4/graphql/ws'
+    },
+    preview: {
+        relayUrl: 'wss://rpc.preview.midnight.network',
+        provingServerUrl: MIDNIGHT_PROOF_SERVER_URL,
+        indexerHttpUrl: 'https://indexer.preview.midnight.network/api/v4/graphql',
+        indexerWsUrl: 'wss://indexer.preview.midnight.network/api/v4/graphql/ws'
+    }
+};
 /**
  * Resolves a caller-supplied network identifier (numeric 0/1, network name, or
- * `midnight:<network>` chainId) to the facade network tag. Defaults to 'preview'.
+ * `midnight:<network>` chainId) to the facade network tag. Omitting it defaults
+ * to 'preview'.
+ *
+ * Throws on anything else rather than falling back, for the same reason
+ * {@link getNetworkIdFromChainId} does: an unrecognized identifier that quietly
+ * became 'preview' would have the caller sync one network while signing with
+ * another network's replay-protection ID, with no error to show for it.
  */ var resolveMidnightNetworkTag = function(networkId) {
     if (networkId === undefined || networkId === null) return 'preview';
-    if (typeof networkId === 'number') return networkId === 1 ? 'mainnet' : 'preview';
+    if (typeof networkId === 'number') {
+        if (networkId === MIDNIGHT_NETWORK_IDS.mainnet) return 'mainnet';
+        if (networkId === MIDNIGHT_NETWORK_IDS.preview) return 'preview';
+        throw new Error("".concat(ERROR_UNKNOWN_NETWORK, ": ").concat(networkId));
+    }
     var name = networkId.includes(':') ? networkId.split(':')[1] : networkId;
-    return name === 'mainnet' ? 'mainnet' : 'preview';
+    if (name === 'mainnet' || name === 'preview') return name;
+    throw new Error("".concat(ERROR_UNKNOWN_NETWORK, ": ").concat(networkId));
+};
+/**
+ * Resolves a network name (or `midnight:<network>` chainId) to its numeric
+ * network ID.
+ *
+ * Throws on unrecognized input rather than defaulting — silently falling back to
+ * mainnet would bake the wrong network ID into the transaction hash and break
+ * replay protection.
+ */ var getNetworkIdFromChainId = function(networkOrChainId) {
+    if (networkOrChainId in MIDNIGHT_NETWORK_IDS) {
+        return MIDNIGHT_NETWORK_IDS[networkOrChainId];
+    }
+    if (networkOrChainId.includes(':')) {
+        var network = networkOrChainId.split(':')[1];
+        if (network && network in MIDNIGHT_NETWORK_IDS) {
+            return MIDNIGHT_NETWORK_IDS[network];
+        }
+    }
+    var known = Object.keys(MIDNIGHT_NETWORK_IDS).join(', ');
+    throw new Error("".concat(ERROR_UNKNOWN_NETWORK, ': "').concat(networkOrChainId, '". Expected one of: ').concat(known, ', or "midnight:<network>".'));
 };
 var ERROR_KEYGEN_FAILED = 'Error with keygen';
 var ERROR_CREATE_WALLET_ACCOUNT = 'Error creating midnight wallet account';
@@ -31,6 +88,53 @@ var ERROR_IMPORT_PRIVATE_KEY = 'Error importing private key';
 var ERROR_EXPORT_PRIVATE_KEY = 'Error exporting private key';
 var ERROR_SIGN_MESSAGE = 'Error signing message';
 var ERROR_ACCOUNT_ADDRESS_REQUIRED = 'Account address is required';
+var ERROR_SIGN_TRANSACTION = 'Error signing transaction';
+var ERROR_UNKNOWN_NETWORK = 'Unknown Midnight network';
+var ERROR_NETWORK_ID_REQUIRED = 'Network ID is required for Midnight transactions';
+var ERROR_NO_DUST = 'No dust balance — register dust first';
+var ERROR_SUBMIT_TRANSACTION = 'Error submitting transaction';
+var ERROR_CREATE_TRANSFER = 'Error creating transfer transaction';
+var ERROR_GET_BALANCE = 'Error fetching balance';
+var ERROR_REGISTER_DUST = 'Error registering dust';
+var ERROR_BALANCE_TRANSACTION = 'Error balancing contract transaction';
+
+/** Whether a sub-wallet side has finished syncing. `highestRelevantIndex` is 0
+ *  during sync, so `isStrictlyComplete()` is the authoritative signal. */ var isSideSynced = function(side) {
+    var _side_state;
+    var _side_progress;
+    var p = (_side_progress = side === null || side === void 0 ? void 0 : side.progress) !== null && _side_progress !== void 0 ? _side_progress : side === null || side === void 0 ? void 0 : (_side_state = side.state) === null || _side_state === void 0 ? void 0 : _side_state.progress;
+    if (!p) return false;
+    if (typeof p.isStrictlyComplete === 'function') return p.isStrictlyComplete();
+    var _p_appliedIndex;
+    var applied = BigInt((_p_appliedIndex = p.appliedIndex) !== null && _p_appliedIndex !== void 0 ? _p_appliedIndex : 0n);
+    var _p_highestRelevantIndex;
+    var highestRelevant = BigInt((_p_highestRelevantIndex = p.highestRelevantIndex) !== null && _p_highestRelevantIndex !== void 0 ? _p_highestRelevantIndex : 0n);
+    return highestRelevant > 0n && applied >= highestRelevant;
+};
+var isSyncResolved = function(state, mode) {
+    return mode === 'full' ? Boolean(state.isSynced) : isSideSynced(state.shielded) && isSideSynced(state.unshielded);
+};
+/**
+ * Whether a checkpoint may be restored into a facade for `network`.
+ *
+ * A checkpoint is only meaningful for the network it was taken on — sync
+ * indices do not carry across — so a mismatch is treated as no checkpoint at
+ * all rather than as an error, since the caller may legitimately hold state for
+ * several networks.
+ */ var isRestorableState = function(state, network) {
+    return state !== undefined && typeof state.shielded === 'string' && typeof state.dust === 'string' && state.network === network;
+};
+/**
+ * Whether the wallet is at a clean resting point, with nothing in flight.
+ *
+ * Checkpointing mid-flight would bake pending entries into whatever the caller
+ * stores and carry them forward on every later restore, so a dirty wallet is
+ * skipped and the caller simply keeps its previous checkpoint.
+ */ var isCleanForCheckpoint = function(state) {
+    var _state_pending_all, _state_pending, _state_unshielded_pendingCoins, _state_unshielded, _state_shielded_pendingCoins, _state_shielded, _state_dust_pendingCoins, _state_dust;
+    var _state_pending_all_length, _state_unshielded_pendingCoins_length, _state_shielded_pendingCoins_length, _state_dust_pendingCoins_length;
+    return ((_state_pending_all_length = state === null || state === void 0 ? void 0 : (_state_pending = state.pending) === null || _state_pending === void 0 ? void 0 : (_state_pending_all = _state_pending.all) === null || _state_pending_all === void 0 ? void 0 : _state_pending_all.length) !== null && _state_pending_all_length !== void 0 ? _state_pending_all_length : 0) === 0 && ((_state_unshielded_pendingCoins_length = state === null || state === void 0 ? void 0 : (_state_unshielded = state.unshielded) === null || _state_unshielded === void 0 ? void 0 : (_state_unshielded_pendingCoins = _state_unshielded.pendingCoins) === null || _state_unshielded_pendingCoins === void 0 ? void 0 : _state_unshielded_pendingCoins.length) !== null && _state_unshielded_pendingCoins_length !== void 0 ? _state_unshielded_pendingCoins_length : 0) === 0 && ((_state_shielded_pendingCoins_length = state === null || state === void 0 ? void 0 : (_state_shielded = state.shielded) === null || _state_shielded === void 0 ? void 0 : (_state_shielded_pendingCoins = _state_shielded.pendingCoins) === null || _state_shielded_pendingCoins === void 0 ? void 0 : _state_shielded_pendingCoins.length) !== null && _state_shielded_pendingCoins_length !== void 0 ? _state_shielded_pendingCoins_length : 0) === 0 && ((_state_dust_pendingCoins_length = state === null || state === void 0 ? void 0 : (_state_dust = state.dust) === null || _state_dust === void 0 ? void 0 : (_state_dust_pendingCoins = _state_dust.pendingCoins) === null || _state_dust_pendingCoins === void 0 ? void 0 : _state_dust_pendingCoins.length) !== null && _state_dust_pendingCoins_length !== void 0 ? _state_dust_pendingCoins_length : 0) === 0;
+};
 
 function _array_like_to_array$1(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -295,6 +399,40 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _possible_constructor_return(self, call) {
     if (call && (_type_of(call) === "object" || typeof call === "function")) {
         return call;
@@ -426,10 +564,117 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
 var logError = createLogError('node-midnight');
-// Unshielded is NON-hardened to match the server's MPC signing path (Sodot's
-// derivePrivateKeyFromXpriv is non-hardened-only). Shielded and dust are hardened Midnight-canonical paths; those roles are signed
-// entirely client-side, so the Sodot constraint does not apply.
+/** Strict base64, optional padding — validated before host input reaches the
+ *  WASM deserializer, which accepts silently-truncated garbage otherwise. */ var BASE64_PATTERN = /^[A-Za-z0-9+/]+={0,2}$/;
+/** Upper bound on a serialized transaction we will decode. Generous next to real
+ *  transactions, small enough that a hostile payload is rejected before WASM. */ var MAX_SERIALIZED_TRANSACTION_BYTES = 4 * 1024 * 1024;
+var SYNC_TIMEOUT_MS = 300000;
+/** One retry is enough: the stale socket reports closed by the second attempt. */ var SUBMIT_ATTEMPTS = 2;
+var SUBMIT_RETRY_DELAY_MS = 1000;
+/**
+ * Whether an error is the node client's stale-connection failure rather than a
+ * ledger rejection.
+ *
+ * The websocket close reason sits several `cause` levels below the
+ * `SubmissionError` the facade surfaces, and Effect's `FiberFailure` exposes
+ * none of them as a readable `cause` property — the chain is only reachable
+ * through the rendered form, so that is what gets matched.
+ */ var isStaleConnectionError = function(error) {
+    return /disconnected from|WebSocket is not connected|Normal Closure/i.test(inspect(error, {
+        depth: 8
+    }));
+};
+/**
+ * Parses a caller-supplied transfer amount.
+ *
+ * `BigInt()` is too lenient to use directly here: `BigInt('')` is `0n`, so an
+ * empty amount would silently become a zero-value transfer, and `BigInt('-5')`
+ * yields a negative that trivially passes the balance check. Decimals do throw,
+ * but with an opaque message.
+ */ var parseTransferAmount = function(amount) {
+    if (typeof amount !== 'string' || !/^\d+$/.test(amount)) {
+        throw new Error("Invalid transfer amount ".concat(JSON.stringify(amount), ": expected a whole number in the token's smallest unit, as a string"));
+    }
+    var parsed = BigInt(amount);
+    if (parsed === 0n) {
+        throw new Error('Transfer amount must be greater than zero');
+    }
+    return parsed;
+};
+/**
+ * `submitTransaction` returns either a string txId or a TransactionIdentifier
+ * with `.toHex()`; normalize so callers always get a string.
+ */ var toTxHashString = function(txIdentifier) {
+    if (typeof txIdentifier === 'string') return txIdentifier;
+    var maybeHex = txIdentifier === null || txIdentifier === void 0 ? void 0 : txIdentifier.toHex;
+    if (typeof maybeHex === 'function') return txIdentifier.toHex();
+    return String(txIdentifier);
+};
+/**
+ * Validates caller-supplied base64 before it reaches the WASM deserializer.
+ * `Buffer.from(x, 'base64')` silently drops invalid characters, so a malformed
+ * payload would otherwise arrive as truncated-but-plausible bytes and fail deep
+ * inside WASM with an opaque error.
+ */ var decodeSerializedTransaction = function(transaction, label) {
+    if (!transaction || !BASE64_PATTERN.test(transaction)) {
+        throw new Error("".concat(label, ": transaction must be base64"));
+    }
+    var bytes = Buffer.from(transaction, 'base64');
+    if (bytes.length === 0 || bytes.length > MAX_SERIALIZED_TRANSACTION_BYTES) {
+        throw new Error("".concat(label, ": transaction must decode to 1..").concat(MAX_SERIALIZED_TRANSACTION_BYTES, " bytes, got ").concat(bytes.length));
+    }
+    return new Uint8Array(bytes);
+};
+/**
+ * Parses a caller-supplied ISO-8601 timestamp.
+ *
+ * `new Date()` alone is too lenient to enforce the contract: it accepts
+ * implementation-defined formats like `'March 5, 2026'`, and `'2026-13-45'`
+ * parses on some engines. A TTL misread by a few hours silently changes when
+ * the balanced transaction stops being valid, so the shape is checked first.
+ */ /**
+ * Anchored at both ends: `new Date()` also understands worded formats such as
+ * `'2026-09-01 1:00 PM'` and `'2026-09-01 12:00 EST'`, which are V8 extensions
+ * rather than ISO-8601 and parse differently — or not at all — elsewhere.
+ * Matching only a prefix would let those through.
+ *
+ * Spelled `\d\d` rather than `\d{2}` because each counted repetition adds to
+ * the regex complexity budget, and the nesting here already uses most of it.
+ */ var ISO_TIMESTAMP = /^(\d\d\d\d)-(\d\d)-(\d\d)([T ]\d\d:\d\d(:\d\d)?(\.\d+)?(Z|[+-]\d\d:?\d\d)?)?$/;
+/** Whether the y/m/d the caller wrote is a date that exists. */ var isRealCalendarDate = function(year, month, day) {
+    var asUtc = new Date("".concat(year, "-").concat(month, "-").concat(day, "T00:00:00Z"));
+    return !Number.isNaN(asUtc.getTime()) && asUtc.getUTCDate() === Number(day);
+};
+var parseIsoTimestamp = function(value, label) {
+    // Date rolls impossible days forward instead of rejecting them, so
+    // '2026-02-29' becomes 1 March and the transaction outlives its stated ttl.
+    var match = ISO_TIMESTAMP.exec(value);
+    var parsed = match && isRealCalendarDate(match[1], match[2], match[3]) ? new Date(value) : new Date(Number.NaN);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new TypeError("".concat(label, ": ttl must be a valid ISO-8601 date, got ").concat(JSON.stringify(value)));
+    }
+    return parsed;
+};
+// Unshielded is NON-hardened to match Sodot's derivePrivateKeyFromXpriv, which
+// is non-hardened-only. The hardened Midnight-canonical path would make the
+// wallet track a different address than the server signs for — no error, just
+// silently diverging balances. Shielded and dust use the hardened canonical
+// paths; those roles are signed client-side, so the constraint does not apply.
 var ROLE_DERIVATION_PATHS = {
     unshielded: 'm/44/2400/0/0/0',
     shielded: "m/44'/2400'/0'/3/0",
@@ -1022,6 +1267,1414 @@ var DynamicMidnightWalletClient = /*#__PURE__*/ function(DynamicWalletClient) {
                 })();
             }
         },
+        {
+            key: "withWallet",
+            value: /**
+   * Boots a synced wallet, runs `use` against it, and stops it afterwards.
+   *
+   * Nothing is retained between calls: the wallet is created here and torn down
+   * in `finally`, so the client holds no state of its own. Callers who want to
+   * avoid the ~150s genesis sync pass back the checkpoint from a previous call
+   * (`access.walletState`) and receive an updated one alongside every result.
+   */ function withWallet(label, access, mode, use) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var network, booted, state, result, _ref, durable, session;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                network = resolveMidnightNetworkTag(access.networkId);
+                                return [
+                                    4,
+                                    _this.bootWallet(label, access, network)
+                                ];
+                            case 1:
+                                booted = _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    ,
+                                    6,
+                                    10
+                                ]);
+                                return [
+                                    4,
+                                    _this.waitForSync(booted.wallet, mode, label)
+                                ];
+                            case 3:
+                                state = _state.sent();
+                                return [
+                                    4,
+                                    use(_object_spread_props(_object_spread({}, booted), {
+                                        state: state
+                                    }))
+                                ];
+                            case 4:
+                                result = _state.sent();
+                                return [
+                                    4,
+                                    _this.checkpoint(booted.wallet, network, label)
+                                ];
+                            case 5:
+                                _ref = _state.sent(), durable = _ref.durable, session = _ref.session;
+                                return [
+                                    2,
+                                    {
+                                        result: result,
+                                        walletState: durable,
+                                        sessionState: session
+                                    }
+                                ];
+                            case 6:
+                                _state.trys.push([
+                                    6,
+                                    8,
+                                    ,
+                                    9
+                                ]);
+                                return [
+                                    4,
+                                    booted.wallet.stop()
+                                ];
+                            case 7:
+                                _state.sent();
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 8:
+                                _state.sent();
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 9:
+                                return [
+                                    7
+                                ];
+                            case 10:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "checkpoint",
+            value: /**
+   * Serializes the wallet's shielded and dust state, or returns undefined when
+   * the wallet has work in flight.
+   *
+   * Checkpointing a dirty wallet would carry pending entries forward into every
+   * later restore, so the caller keeps its previous checkpoint instead — sync
+   * reconciles against the chain either way.
+   */ function checkpoint(wallet, network, label) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var current, _ref, shielded, dust, state, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    _this.readState(wallet)
+                                ];
+                            case 1:
+                                current = _state.sent();
+                                return [
+                                    4,
+                                    Promise.all([
+                                        wallet.shielded.serializeState(),
+                                        wallet.dust.serializeState()
+                                    ])
+                                ];
+                            case 2:
+                                _ref = _sliced_to_array.apply(void 0, [
+                                    _state.sent(),
+                                    2
+                                ]), shielded = _ref[0], dust = _ref[1];
+                                state = {
+                                    shielded: shielded,
+                                    dust: dust,
+                                    network: network,
+                                    savedAt: Date.now()
+                                };
+                                // A dirty snapshot is still the truth about what this wallet has spent,
+                                // so it is kept for the session; it is only withheld from the caller,
+                                // who would otherwise carry pending entries forward on every restore.
+                                if (!isCleanForCheckpoint(current)) {
+                                    _this.logger.info("[Midnight] ".concat(label, ": skipping checkpoint, wallet has work in flight"));
+                                    return [
+                                        2,
+                                        {
+                                            session: state
+                                        }
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    {
+                                        durable: state,
+                                        session: state
+                                    }
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                // A checkpoint is an optimisation; failing to take one must not fail the
+                                // operation the caller actually asked for.
+                                _this.logger.warn("[Midnight] ".concat(label, ": could not take checkpoint"), error);
+                                return [
+                                    2,
+                                    {}
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "submitWithReconnect",
+            value: /**
+   * Submits, retrying once past a stale-connection failure.
+   *
+   * The facade's node client calls `api.disconnect()` during startup, and that
+   * promise resolves before the socket has actually closed. A submit issued in
+   * that window sees `isConnected === true`, skips reconnecting, and is then
+   * rejected by the close that lands a moment later. The retry reconnects for
+   * real, because by then the socket reports closed. Resubmitting is safe: the
+   * bytes never reached the node, and an identical transaction has an identical
+   * hash, so a duplicate would be rejected rather than spent twice.
+   */ function submitWithReconnect(wallet, finalized) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var attempt, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                attempt = 1;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    wallet.submitTransaction(finalized)
+                                ];
+                            case 2:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                if (attempt >= SUBMIT_ATTEMPTS || !isStaleConnectionError(error)) throw error;
+                                _this.logger.warn("[Midnight] submitTransaction: node connection was stale, reconnecting and retrying");
+                                return [
+                                    4,
+                                    new Promise(function(resolve) {
+                                        return setTimeout(resolve, SUBMIT_RETRY_DELAY_MS);
+                                    })
+                                ];
+                            case 4:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                attempt++;
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 6:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "readState",
+            value: /** First emission from the wallet's state observable. */ function readState(wallet) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            new Promise(function(resolve, reject) {
+                                // eslint-disable-next-line prefer-const
+                                var sub;
+                                var timeout = setTimeout(function() {
+                                    sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                    reject(new Error('timed out reading wallet state'));
+                                }, 10000);
+                                sub = wallet.state().subscribe(function(state) {
+                                    clearTimeout(timeout);
+                                    queueMicrotask(function() {
+                                        return sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                    });
+                                    resolve(state);
+                                });
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "bootWallet",
+            value: function bootWallet(label, access, network) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var roleKeys, shieldedSecretKeys, dustSecretKey, unshieldedKeystore, checkpoint, infra, wallet;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.getRoleKeys(access)
+                                ];
+                            case 1:
+                                roleKeys = _state.sent();
+                                shieldedSecretKeys = ledger.ZswapSecretKeys.fromSeed(new Uint8Array(Buffer.from(roleKeys.shielded, 'hex')));
+                                dustSecretKey = ledger.DustSecretKey.fromSeed(new Uint8Array(Buffer.from(roleKeys.dust, 'hex')));
+                                unshieldedKeystore = createKeystore(new Uint8Array(Buffer.from(roleKeys.unshielded, 'hex')), network);
+                                // A checkpoint from another network would corrupt sync, so a mismatch is
+                                // treated as absent rather than as an error — callers may hold several.
+                                checkpoint = isRestorableState(access.walletState, network) ? access.walletState : undefined;
+                                infra = MIDNIGHT_INFRA[network];
+                                _this.logger.info("[Midnight] ".concat(label, ": initializing wallet facade (").concat(network, ", ").concat(checkpoint ? "resuming from checkpoint saved ".concat(new Date(checkpoint.savedAt).toISOString()) : 'syncing from genesis', ")"));
+                                return [
+                                    4,
+                                    WalletFacade.init({
+                                        configuration: {
+                                            networkId: network,
+                                            costParameters: {
+                                                feeBlocksMargin: 5
+                                            },
+                                            relayURL: new URL(infra.relayUrl),
+                                            provingServerUrl: new URL(infra.provingServerUrl),
+                                            indexerClientConnection: {
+                                                indexerHttpUrl: infra.indexerHttpUrl,
+                                                indexerWsUrl: infra.indexerWsUrl
+                                            },
+                                            // Measured: 2000 and 20000 both sync in ~150s — the fold is apply-bound
+                                            // (per-entry WASM compute), not fetch-bound, so batch size is not a lever.
+                                            batchUpdates: {
+                                                size: 2000
+                                            },
+                                            txHistoryStorage: new NoOpTransactionHistoryStorage()
+                                        },
+                                        shielded: function(cfg) {
+                                            return checkpoint ? ShieldedWallet(cfg).restore(checkpoint.shielded) : ShieldedWallet(cfg).startWithSecretKeys(shieldedSecretKeys);
+                                        },
+                                        unshielded: function(cfg) {
+                                            return UnshieldedWallet(cfg).startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore));
+                                        },
+                                        dust: function(cfg) {
+                                            return checkpoint ? DustWallet(cfg).restore(checkpoint.dust) : DustWallet(cfg).startWithSecretKey(dustSecretKey, ledger.LedgerParameters.initialParameters().dust);
+                                        }
+                                    })
+                                ];
+                            case 2:
+                                wallet = _state.sent();
+                                return [
+                                    4,
+                                    wallet.start(shieldedSecretKeys, dustSecretKey)
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        wallet: wallet,
+                                        roleKeys: roleKeys,
+                                        shieldedSecretKeys: shieldedSecretKeys,
+                                        dustSecretKey: dustSecretKey
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "waitForSync",
+            value: /**
+   * Resolves once the requested sides report synced.
+   *
+   * Does not stop the wallet on failure — `withWallet` owns the wallet's
+   * lifetime and tears it down in `finally`, whether this resolves or throws.
+   */ function waitForSync(wallet, mode, label) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var startedAt, lastLoggedAt;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                startedAt = Date.now();
+                                lastLoggedAt = 0;
+                                return [
+                                    4,
+                                    new Promise(function(resolve, reject) {
+                                        // `let` + optional chaining: an already-synced wallet emits synchronously
+                                        // during .subscribe(), so the callback can touch `sub` before assignment.
+                                        // eslint-disable-next-line prefer-const
+                                        var sub;
+                                        var timeout = setTimeout(function() {
+                                            sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                            reject(new Error("[Midnight] ".concat(label, ": wallet sync timeout after ").concat(SYNC_TIMEOUT_MS, "ms")));
+                                        }, SYNC_TIMEOUT_MS);
+                                        sub = wallet.state().subscribe(function(state) {
+                                            var now = Date.now();
+                                            if (now - lastLoggedAt > 15000) {
+                                                lastLoggedAt = now;
+                                                _this.logger.info("[Midnight] ".concat(label, ": syncing ").concat(((now - startedAt) / 1000).toFixed(0), "s \xb7 ") + "shielded=".concat(isSideSynced(state.shielded), " unshielded=").concat(isSideSynced(state.unshielded), " ") + "dust=".concat(isSideSynced(state.dust)));
+                                            }
+                                            if (isSyncResolved(state, mode)) {
+                                                clearTimeout(timeout);
+                                                queueMicrotask(function() {
+                                                    return sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                                });
+                                                _this.logger.info("[Midnight] ".concat(label, ": synced in ").concat(((now - startedAt) / 1000).toFixed(1), "s (").concat(mode, ")"));
+                                                resolve(state);
+                                            }
+                                        });
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getBalances",
+            value: /**
+   * Reads unshielded, shielded, and dust balances.
+   *
+   * Resolves as soon as shielded + unshielded are synced, leaving dust folding in
+   * the background — `dustSynced` says whether the dust figure is final yet.
+   */ function getBalances(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _ref, result, walletState, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                return [
+                                    4,
+                                    _this.withWallet('getBalances', access, 'shielded-unshielded', /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(param) {
+                                            var state, _state_dust_balance, _state_dust, _state_dust1, _state_unshielded, _state_shielded, toStringMap, now, _state_dust_balance1, dustBalance, _state_dust_totalCoins, dustCap;
+                                            return _ts_generator(this, function(_state) {
+                                                state = param.state;
+                                                toStringMap = function() {
+                                                    var balances = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                                                    return Object.fromEntries(Object.entries(balances).map(function(param) {
+                                                        var _param = _sliced_to_array(param, 2), token = _param[0], value = _param[1];
+                                                        return [
+                                                            token,
+                                                            value.toString()
+                                                        ];
+                                                    }));
+                                                };
+                                                now = new Date();
+                                                dustBalance = (_state_dust_balance1 = (_state_dust = state.dust) === null || _state_dust === void 0 ? void 0 : (_state_dust_balance = _state_dust.balance) === null || _state_dust_balance === void 0 ? void 0 : _state_dust_balance.call(_state_dust, now)) !== null && _state_dust_balance1 !== void 0 ? _state_dust_balance1 : 0n;
+                                                // v4 exposes the generation cap per coin; the wallet-level cap is their sum.
+                                                dustCap = ((_state_dust_totalCoins = (_state_dust1 = state.dust) === null || _state_dust1 === void 0 ? void 0 : _state_dust1.totalCoins) !== null && _state_dust_totalCoins !== void 0 ? _state_dust_totalCoins : []).reduce(function(sum, coin) {
+                                                    var _coin_maxCap;
+                                                    return sum + ((_coin_maxCap = coin.maxCap) !== null && _coin_maxCap !== void 0 ? _coin_maxCap : 0n);
+                                                }, 0n);
+                                                return [
+                                                    2,
+                                                    {
+                                                        unshielded: toStringMap((_state_unshielded = state.unshielded) === null || _state_unshielded === void 0 ? void 0 : _state_unshielded.balances),
+                                                        shielded: toStringMap((_state_shielded = state.shielded) === null || _state_shielded === void 0 ? void 0 : _state_shielded.balances),
+                                                        dust: {
+                                                            balance: dustBalance.toString(),
+                                                            cap: dustCap.toString()
+                                                        },
+                                                        dustSynced: isSideSynced(state.dust),
+                                                        address: access.walletMetadata.accountAddress
+                                                    }
+                                                ];
+                                            });
+                                        });
+                                        return function(_) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 1:
+                                _ref = _state.sent(), result = _ref.result, walletState = _ref.walletState;
+                                return [
+                                    2,
+                                    _object_spread_props(_object_spread({}, result), {
+                                        walletState: walletState
+                                    })
+                                ];
+                            case 2:
+                                error = _state.sent();
+                                logError({
+                                    message: ERROR_GET_BALANCE,
+                                    error: error,
+                                    context: {
+                                        accountAddress: access.walletMetadata.accountAddress
+                                    }
+                                });
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_GET_BALANCE);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "registerDust",
+            value: /**
+   * Registers the wallet's NIGHT UTXOs for dust generation. Dust pays fees on
+   * every Midnight transaction, so this is a prerequisite for transacting.
+   *
+   * Returns immediately after broadcast — dust accrues continuously on-chain and
+   * can take minutes, so poll {@link getBalances} rather than blocking here.
+   */ function registerDust(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _ref, result, walletState, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                return [
+                                    4,
+                                    _this.withWallet('registerDust', access, 'full', /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(param) {
+                                            var wallet, roleKeys, state, _state_dust_balance, _state_dust, _state_unshielded, _state_dust_balance1, existingDust, _state_unshielded_availableCoins, allUtxos, unregistered, registered, verifyingKey, recipe, finalized, txId;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        wallet = param.wallet, roleKeys = param.roleKeys, state = param.state;
+                                                        existingDust = (_state_dust_balance1 = (_state_dust = state.dust) === null || _state_dust === void 0 ? void 0 : (_state_dust_balance = _state_dust.balance) === null || _state_dust_balance === void 0 ? void 0 : _state_dust_balance.call(_state_dust, new Date())) !== null && _state_dust_balance1 !== void 0 ? _state_dust_balance1 : 0n;
+                                                        if (existingDust > 0n) {
+                                                            return [
+                                                                2,
+                                                                {
+                                                                    status: 'already_has_dust',
+                                                                    message: "Wallet already has ".concat(existingDust, " dust; no action needed."),
+                                                                    registeredCount: 0,
+                                                                    dustBalance: existingDust.toString()
+                                                                }
+                                                            ];
+                                                        }
+                                                        // The flag lives under `.meta`, not on the coin itself — reading it one
+                                                        // level up is silently always undefined, which makes every UTXO look
+                                                        // unregistered and re-submits a registration tx on every call. Matches
+                                                        // packages/midnight (browser), which reads the same shape.
+                                                        allUtxos = (_state_unshielded_availableCoins = (_state_unshielded = state.unshielded) === null || _state_unshielded === void 0 ? void 0 : _state_unshielded.availableCoins) !== null && _state_unshielded_availableCoins !== void 0 ? _state_unshielded_availableCoins : [];
+                                                        unregistered = allUtxos.filter(function(utxo) {
+                                                            var _utxo_meta;
+                                                            return ((_utxo_meta = utxo.meta) === null || _utxo_meta === void 0 ? void 0 : _utxo_meta.registeredForDustGeneration) !== true;
+                                                        });
+                                                        if (unregistered.length === 0) {
+                                                            registered = allUtxos.length > 0;
+                                                            return [
+                                                                2,
+                                                                {
+                                                                    status: registered ? 'already_registered' : 'no_utxos',
+                                                                    message: registered ? "All ".concat(allUtxos.length, " NIGHT UTXO(s) are already registered. Dust accrues on-chain — poll getBalances.") : 'No NIGHT UTXOs. Fund the wallet with NIGHT before registering for dust.',
+                                                                    registeredCount: 0,
+                                                                    dustBalance: '0'
+                                                                }
+                                                            ];
+                                                        }
+                                                        verifyingKey = ledger.signatureVerifyingKey(roleKeys.unshielded);
+                                                        return [
+                                                            4,
+                                                            wallet.registerNightUtxosForDustGeneration(unregistered, verifyingKey, function(payload) {
+                                                                return ledger.signData(roleKeys.unshielded, payload);
+                                                            })
+                                                        ];
+                                                    case 1:
+                                                        recipe = _state.sent();
+                                                        return [
+                                                            4,
+                                                            wallet.finalizeRecipe(recipe)
+                                                        ];
+                                                    case 2:
+                                                        finalized = _state.sent();
+                                                        return [
+                                                            4,
+                                                            wallet.submitTransaction(finalized)
+                                                        ];
+                                                    case 3:
+                                                        txId = toTxHashString.apply(void 0, [
+                                                            _state.sent()
+                                                        ]);
+                                                        return [
+                                                            2,
+                                                            {
+                                                                status: 'registered',
+                                                                message: "Registered ".concat(unregistered.length, " NIGHT UTXO(s) for dust generation (tx ").concat(txId.slice(0, 16), "…). ") + 'Dust accrues continuously — poll getBalances to see it arrive.',
+                                                                registeredCount: unregistered.length,
+                                                                dustBalance: '0',
+                                                                txId: txId
+                                                            }
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(_) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 1:
+                                _ref = _state.sent(), result = _ref.result, walletState = _ref.walletState;
+                                return [
+                                    2,
+                                    _object_spread_props(_object_spread({}, result), {
+                                        walletState: walletState
+                                    })
+                                ];
+                            case 2:
+                                error = _state.sent();
+                                logError({
+                                    message: ERROR_REGISTER_DUST,
+                                    error: error,
+                                    context: {
+                                        accountAddress: access.walletMetadata.accountAddress
+                                    }
+                                });
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_REGISTER_DUST);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "createTransferTransaction",
+            value: /**
+   * Builds an unsigned transfer. No MPC, no proving, no broadcast — pair with
+   * {@link signTransaction} then {@link submitTransaction}.
+   */ function createTransferTransaction(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var transfers, _access_ttlMinutes, ttlMinutes, _ref, result, walletState, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                transfers = access.transfers, _access_ttlMinutes = access.ttlMinutes, ttlMinutes = _access_ttlMinutes === void 0 ? 5 : _access_ttlMinutes;
+                                if (!(transfers === null || transfers === void 0 ? void 0 : transfers.length)) {
+                                    throw new Error('At least one transfer is required');
+                                }
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    _this.withWallet('createTransferTransaction', access, 'full', /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(param) {
+                                            var wallet, state, shieldedSecretKeys, dustSecretKey, _state_dust_balance, _state_dust, _state_dust_balance1, nativeToken, network, requiredByKey, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, transfer, _transfer_tokenType, token, key, existing, _existing_required, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value, side, token1, required, _state_unshielded, _state_shielded, balances, _balances_token, have, sdkTransfers, recipe;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        wallet = param.wallet, state = param.state, shieldedSecretKeys = param.shieldedSecretKeys, dustSecretKey = param.dustSecretKey;
+                                                        // Dust pays the fee on every Midnight transaction regardless of transfer type.
+                                                        if (((_state_dust_balance1 = (_state_dust = state.dust) === null || _state_dust === void 0 ? void 0 : (_state_dust_balance = _state_dust.balance) === null || _state_dust_balance === void 0 ? void 0 : _state_dust_balance.call(_state_dust, new Date())) !== null && _state_dust_balance1 !== void 0 ? _state_dust_balance1 : 0n) === 0n) {
+                                                            throw new Error(ERROR_NO_DUST);
+                                                        }
+                                                        nativeToken = ledger.nativeToken().raw;
+                                                        network = resolveMidnightNetworkTag(access.networkId);
+                                                        // Aggregate per (side, token) so multiple outputs spending the same token
+                                                        // are checked against one combined total. NUL separator: it cannot appear
+                                                        // in any Midnight address or token encoding, so keys never collide (a
+                                                        // token identifier may itself contain ':').
+                                                        requiredByKey = new Map();
+                                                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                                        try {
+                                                            for(_iterator = transfers[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                                                transfer = _step.value;
+                                                                ;
+                                                                token = (_transfer_tokenType = transfer.tokenType) !== null && _transfer_tokenType !== void 0 ? _transfer_tokenType : nativeToken;
+                                                                key = "".concat(transfer.type, "\0").concat(token);
+                                                                existing = requiredByKey.get(key);
+                                                                ;
+                                                                requiredByKey.set(key, {
+                                                                    side: transfer.type,
+                                                                    token: token,
+                                                                    required: ((_existing_required = existing === null || existing === void 0 ? void 0 : existing.required) !== null && _existing_required !== void 0 ? _existing_required : 0n) + parseTransferAmount(transfer.amount)
+                                                                });
+                                                            }
+                                                        } catch (err) {
+                                                            _didIteratorError = true;
+                                                            _iteratorError = err;
+                                                        } finally{
+                                                            try {
+                                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                                    _iterator.return();
+                                                                }
+                                                            } finally{
+                                                                if (_didIteratorError) {
+                                                                    throw _iteratorError;
+                                                                }
+                                                            }
+                                                        }
+                                                        _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                                        try {
+                                                            for(_iterator1 = requiredByKey.values()[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                                                _step_value = _step1.value, side = _step_value.side, token1 = _step_value.token, required = _step_value.required;
+                                                                ;
+                                                                balances = side === 'unshielded' ? (_state_unshielded = state.unshielded) === null || _state_unshielded === void 0 ? void 0 : _state_unshielded.balances : (_state_shielded = state.shielded) === null || _state_shielded === void 0 ? void 0 : _state_shielded.balances;
+                                                                ;
+                                                                have = (_balances_token = balances === null || balances === void 0 ? void 0 : balances[token1]) !== null && _balances_token !== void 0 ? _balances_token : 0n;
+                                                                if (have < required) {
+                                                                    throw new Error("Insufficient ".concat(side, " balance for token ").concat(token1, ": ").concat(have, " < ").concat(required));
+                                                                }
+                                                            }
+                                                        } catch (err) {
+                                                            _didIteratorError1 = true;
+                                                            _iteratorError1 = err;
+                                                        } finally{
+                                                            try {
+                                                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                                                    _iterator1.return();
+                                                                }
+                                                            } finally{
+                                                                if (_didIteratorError1) {
+                                                                    throw _iteratorError1;
+                                                                }
+                                                            }
+                                                        }
+                                                        sdkTransfers = transfers.map(function(transfer) {
+                                                            var _transfer_tokenType;
+                                                            var token = (_transfer_tokenType = transfer.tokenType) !== null && _transfer_tokenType !== void 0 ? _transfer_tokenType : nativeToken;
+                                                            // The SDK wants a decoded address object, not the bech32m string.
+                                                            var receiverAddress;
+                                                            try {
+                                                                var parsed = MidnightBech32m.parse(transfer.recipientAddress);
+                                                                receiverAddress = transfer.type === 'unshielded' ? parsed.decode(UnshieldedAddress, network) : parsed.decode(ShieldedAddress, network);
+                                                            } catch (err) {
+                                                                throw new Error("Invalid ".concat(transfer.type, " recipient address ").concat(transfer.recipientAddress, ": ").concat(err.message));
+                                                            }
+                                                            return {
+                                                                type: transfer.type,
+                                                                outputs: [
+                                                                    {
+                                                                        amount: parseTransferAmount(transfer.amount),
+                                                                        receiverAddress: receiverAddress,
+                                                                        type: token
+                                                                    }
+                                                                ]
+                                                            };
+                                                        });
+                                                        return [
+                                                            4,
+                                                            wallet.transferTransaction(sdkTransfers, {
+                                                                shieldedSecretKeys: shieldedSecretKeys,
+                                                                dustSecretKey: dustSecretKey
+                                                            }, {
+                                                                ttl: new Date(Date.now() + ttlMinutes * 60 * 1000)
+                                                            })
+                                                        ];
+                                                    case 1:
+                                                        recipe = _state.sent();
+                                                        if (recipe.type !== 'UNPROVEN_TRANSACTION') {
+                                                            throw new Error("Unexpected recipe type from transferTransaction: ".concat(recipe.type));
+                                                        }
+                                                        return [
+                                                            2,
+                                                            {
+                                                                serializedTransaction: Buffer.from(recipe.transaction.serialize()).toString('base64')
+                                                            }
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(_) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 2:
+                                _ref = _state.sent(), result = _ref.result, walletState = _ref.walletState;
+                                return [
+                                    2,
+                                    _object_spread_props(_object_spread({}, result), {
+                                        walletState: walletState
+                                    })
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                logError({
+                                    message: ERROR_CREATE_TRANSFER,
+                                    error: error,
+                                    context: {
+                                        accountAddress: access.walletMetadata.accountAddress
+                                    }
+                                });
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_CREATE_TRANSFER);
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "submitTransaction",
+            value: /**
+   * Broadcasts a finalized transaction. Pure RPC — reuses the cached wallet's
+   * node connection; no MPC and no proving.
+   *
+   * Returns both identifiers, because they are not interchangeable:
+   * - `txHash` is the canonical ledger hash, and what the block explorer indexes.
+   * - `txIdentifier` is the submission handle; midnight-js polls
+   *   `transactions(offset: { identifier })` to observe inclusion, so a caller
+   *   handed only the hash would wait forever on a transaction that succeeded.
+   */ function submitTransaction(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var bytes, _ref, result, walletState, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Validate before booting the facade — see signTransaction.
+                                bytes = decodeSerializedTransaction(access.transaction, 'submitTransaction');
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    _this.withWallet('submitTransaction', access, 'full', /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(param) {
+                                            var wallet, finalized, txIdentifier, txHash, canonical;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        wallet = param.wallet;
+                                                        finalized = ledger.Transaction.deserialize('signature', 'proof', 'binding', bytes);
+                                                        return [
+                                                            4,
+                                                            _this.submitWithReconnect(wallet, finalized)
+                                                        ];
+                                                    case 1:
+                                                        txIdentifier = toTxHashString.apply(void 0, [
+                                                            _state.sent()
+                                                        ]);
+                                                        txHash = txIdentifier;
+                                                        try {
+                                                            canonical = toTxHashString(finalized.transactionHash());
+                                                            if (canonical) txHash = canonical;
+                                                        } catch (err) {
+                                                            _this.logger.warn('[Midnight] submitTransaction: could not derive canonical hash, using identifier', err);
+                                                        }
+                                                        return [
+                                                            2,
+                                                            {
+                                                                txHash: txHash,
+                                                                txIdentifier: txIdentifier
+                                                            }
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(_) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 2:
+                                _ref = _state.sent(), result = _ref.result, walletState = _ref.walletState;
+                                return [
+                                    2,
+                                    _object_spread_props(_object_spread({}, result), {
+                                        walletState: walletState
+                                    })
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                logError({
+                                    message: ERROR_SUBMIT_TRANSACTION,
+                                    error: error,
+                                    context: {
+                                        accountAddress: access.walletMetadata.accountAddress
+                                    }
+                                });
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_SUBMIT_TRANSACTION);
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "signTransaction",
+            value: /**
+   * MPC-signs every unshielded intent segment, then finalizes (ZK-proves) the
+   * transaction through the proof server.
+   *
+   * Side effect: finalizeRecipe mutates wallet state by adding a pending-tx
+   * entry. If the caller never submits, that entry lingers until the next
+   * re-sync reconciles against the chain.
+   */ function signTransaction(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var transaction, networkId, context, resolvedNetworkId, bytes, _ref, result, walletState, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                transaction = access.transaction, networkId = access.networkId, context = access.context;
+                                if (networkId === undefined) {
+                                    // Never default: the network id is baked into the transaction hash for
+                                    // replay protection, so guessing wrong is a correctness bug, not a nit.
+                                    throw new Error(ERROR_NETWORK_ID_REQUIRED);
+                                }
+                                resolvedNetworkId = typeof networkId === 'number' ? networkId : getNetworkIdFromChainId(networkId);
+                                // Validate before booting the facade: a cold sync is ~150s and getRoleKeys
+                                // runs a full MPC export, neither of which a malformed payload should cost.
+                                bytes = decodeSerializedTransaction(transaction, 'signTransaction');
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    _this.withWallet('signTransaction', access, 'full', /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(param) {
+                                            var wallet, unsignedTx, finalized;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        wallet = param.wallet;
+                                                        unsignedTx = ledger.Transaction.deserialize('signature', 'pre-proof', 'pre-binding', bytes);
+                                                        return [
+                                                            4,
+                                                            _this.mpcSignIntents(unsignedTx, access, {
+                                                                fullTxBase64: transaction,
+                                                                networkId: resolvedNetworkId,
+                                                                baseContext: context
+                                                            })
+                                                        ];
+                                                    case 1:
+                                                        _state.sent();
+                                                        _this.logger.info('[Midnight] signTransaction: finalizing (ZK prove)…');
+                                                        return [
+                                                            4,
+                                                            wallet.finalizeRecipe({
+                                                                type: 'UNPROVEN_TRANSACTION',
+                                                                transaction: unsignedTx
+                                                            })
+                                                        ];
+                                                    case 2:
+                                                        finalized = _state.sent();
+                                                        return [
+                                                            2,
+                                                            Buffer.from(finalized.serialize()).toString('base64')
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(_) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 2:
+                                _ref = _state.sent(), result = _ref.result, walletState = _ref.walletState;
+                                return [
+                                    2,
+                                    {
+                                        transaction: result,
+                                        walletState: walletState
+                                    }
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                logError({
+                                    message: ERROR_SIGN_TRANSACTION,
+                                    error: error,
+                                    context: {
+                                        accountAddress: access.walletMetadata.accountAddress
+                                    }
+                                });
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_SIGN_TRANSACTION);
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getWalletProvider",
+            value: /**
+   * Returns a Midnight.js-compatible wallet provider for use with
+   * midnight-js-contracts (deployment and contract calls). Signing goes through
+   * MPC; no private key is handed to the caller.
+   *
+   * `balanceTx` and `submitTx` boot a wallet per call rather than closing over
+   * one, so nothing is held open between the caller's contract operations. To
+   * keep that from re-syncing from genesis every time, the provider carries the
+   * checkpoint from one call into the next. That state lives in this closure
+   * and dies with the provider — read it with `getWalletState()` to persist it
+   * beyond that.
+   */ function getWalletProvider(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var network, numericNetworkId, resume, durable, queue, withLatest, _ref, coinPublicKey, encryptionPublicKey;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                network = resolveMidnightNetworkTag(access.networkId);
+                                numericNetworkId = MIDNIGHT_NETWORK_IDS[network];
+                                // Two views of the same wallet. `resume` is what the next call boots from
+                                // and includes work in flight, so a second balanceTx cannot re-spend coins
+                                // the first one already reserved. `durable` is the clean subset handed to
+                                // the caller, who must not persist pending entries.
+                                resume = access.walletState;
+                                durable = access.walletState;
+                                // Each operation reads `resume`, awaits, then writes it back, so two
+                                // overlapping calls would both start from the same state and the later
+                                // write would drop the earlier one's reservations. Chaining them means a
+                                // caller that fires several without awaiting still gets them in order.
+                                queue = Promise.resolve();
+                                withLatest = function(label, use) {
+                                    var run = queue.then(/*#__PURE__*/ _async_to_generator(function() {
+                                        var _ref, result, walletState, sessionState;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    return [
+                                                        4,
+                                                        _this.withWallet(label, _object_spread_props(_object_spread({}, access), {
+                                                            walletState: resume
+                                                        }), 'full', use)
+                                                    ];
+                                                case 1:
+                                                    _ref = _state.sent(), result = _ref.result, walletState = _ref.walletState, sessionState = _ref.sessionState;
+                                                    if (sessionState) resume = sessionState;
+                                                    if (walletState) durable = walletState;
+                                                    return [
+                                                        2,
+                                                        result
+                                                    ];
+                                            }
+                                        });
+                                    }));
+                                    // Swallow only for the chain's own sake — `run` still rejects for the
+                                    // caller, but one failure must not poison every later operation.
+                                    queue = run.catch(function() {
+                                        return undefined;
+                                    });
+                                    return run;
+                                };
+                                return [
+                                    4,
+                                    withLatest('walletProvider', /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(param) {
+                                            var state;
+                                            return _ts_generator(this, function(_state) {
+                                                state = param.state;
+                                                return [
+                                                    2,
+                                                    {
+                                                        coinPublicKey: state.shielded.coinPublicKey.toHexString(),
+                                                        encryptionPublicKey: state.shielded.encryptionPublicKey.toHexString()
+                                                    }
+                                                ];
+                                            });
+                                        });
+                                        return function(_) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 1:
+                                _ref = _state.sent(), coinPublicKey = _ref.coinPublicKey, encryptionPublicKey = _ref.encryptionPublicKey;
+                                return [
+                                    2,
+                                    {
+                                        getCoinPublicKey: function() {
+                                            return coinPublicKey;
+                                        },
+                                        getEncryptionPublicKey: function() {
+                                            return encryptionPublicKey;
+                                        },
+                                        getWalletState: function() {
+                                            return durable;
+                                        },
+                                        balanceTx: function(tx, ttl) {
+                                            return withLatest('walletProvider.balanceTx', /*#__PURE__*/ function() {
+                                                var _ref = _async_to_generator(function(param) {
+                                                    var wallet, shieldedSecretKeys, dustSecretKey, recipe;
+                                                    return _ts_generator(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                wallet = param.wallet, shieldedSecretKeys = param.shieldedSecretKeys, dustSecretKey = param.dustSecretKey;
+                                                                return [
+                                                                    4,
+                                                                    wallet.balanceUnboundTransaction(tx, {
+                                                                        shieldedSecretKeys: shieldedSecretKeys,
+                                                                        dustSecretKey: dustSecretKey
+                                                                    }, {
+                                                                        ttl: ttl !== null && ttl !== void 0 ? ttl : new Date(Date.now() + 30 * 60 * 1000)
+                                                                    })
+                                                                ];
+                                                            case 1:
+                                                                recipe = _state.sent();
+                                                                // The base transaction arrives already proven, so it deserializes and
+                                                                // signs under the 'proof' marker; the balancing transaction the SDK
+                                                                // adds has not been proven yet and uses 'pre-proof'.
+                                                                return [
+                                                                    4,
+                                                                    _this.mpcSignIntents(recipe.baseTransaction, access, {
+                                                                        fullTxBase64: Buffer.from(recipe.baseTransaction.serialize()).toString('base64'),
+                                                                        networkId: numericNetworkId,
+                                                                        proofMarker: 'proof'
+                                                                    })
+                                                                ];
+                                                            case 2:
+                                                                _state.sent();
+                                                                if (!recipe.balancingTransaction) return [
+                                                                    3,
+                                                                    4
+                                                                ];
+                                                                return [
+                                                                    4,
+                                                                    _this.mpcSignIntents(recipe.balancingTransaction, access, {
+                                                                        fullTxBase64: Buffer.from(recipe.balancingTransaction.serialize()).toString('base64'),
+                                                                        networkId: numericNetworkId,
+                                                                        proofMarker: 'pre-proof'
+                                                                    })
+                                                                ];
+                                                            case 3:
+                                                                _state.sent();
+                                                                _state.label = 4;
+                                                            case 4:
+                                                                _this.logger.info('[Midnight] walletProvider.balanceTx: finalizing (ZK prove)…');
+                                                                return [
+                                                                    2,
+                                                                    wallet.finalizeRecipe(recipe)
+                                                                ];
+                                                        }
+                                                    });
+                                                });
+                                                return function(_) {
+                                                    return _ref.apply(this, arguments);
+                                                };
+                                            }());
+                                        },
+                                        submitTx: function(tx) {
+                                            return withLatest('walletProvider.submitTx', /*#__PURE__*/ function() {
+                                                var _ref = _async_to_generator(function(param) {
+                                                    var wallet;
+                                                    return _ts_generator(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                wallet = param.wallet;
+                                                                return [
+                                                                    4,
+                                                                    _this.submitWithReconnect(wallet, tx)
+                                                                ];
+                                                            case 1:
+                                                                return [
+                                                                    2,
+                                                                    toTxHashString.apply(void 0, [
+                                                                        _state.sent()
+                                                                    ])
+                                                                ];
+                                                        }
+                                                    });
+                                                });
+                                                return function(_) {
+                                                    return _ref.apply(this, arguments);
+                                                };
+                                            }());
+                                        }
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "balanceContractTransaction",
+            value: /**
+   * Balances a serialized midnight-js UnboundTransaction and returns the
+   * finalized transaction, base64-encoded. A transport-friendly wrapper over
+   * {@link getWalletProvider}'s `balanceTx` for callers that pass transactions
+   * across a process boundary rather than holding ledger objects.
+   */ function balanceContractTransaction(access) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var transaction, ttl, ttlDate, bytes, unbound, provider, finalized, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                transaction = access.transaction, ttl = access.ttl;
+                                // `ttl ? …` would treat '' as absent and quietly apply the default lifetime.
+                                ttlDate = ttl === undefined ? undefined : parseIsoTimestamp(ttl, 'balanceContractTransaction');
+                                // Validated before the facade boots — see signTransaction. An unbound
+                                // contract transaction arrives proven, hence the 'proof' marker.
+                                bytes = decodeSerializedTransaction(transaction, 'balanceContractTransaction');
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                unbound = ledger.Transaction.deserialize('signature', 'proof', 'pre-binding', bytes);
+                                return [
+                                    4,
+                                    _this.getWalletProvider(access)
+                                ];
+                            case 2:
+                                provider = _state.sent();
+                                return [
+                                    4,
+                                    provider.balanceTx(unbound, ttlDate)
+                                ];
+                            case 3:
+                                finalized = _state.sent();
+                                // Booting the provider produces a clean checkpoint before any balancing
+                                // happens; dropping it would make the next call re-sync from genesis.
+                                return [
+                                    2,
+                                    {
+                                        transaction: Buffer.from(finalized.serialize()).toString('base64'),
+                                        walletState: provider.getWalletState()
+                                    }
+                                ];
+                            case 4:
+                                error = _state.sent();
+                                logError({
+                                    message: ERROR_BALANCE_TRANSACTION,
+                                    error: error,
+                                    context: {
+                                        accountAddress: access.walletMetadata.accountAddress
+                                    }
+                                });
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_BALANCE_TRANSACTION);
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "mpcSignIntents",
+            value: /**
+   * Signs each intent segment via MPC and writes the signatures back onto the
+   * transaction.
+   *
+   * Strictly serial. `tx.intents` is an immutable persistent map — `.set()`
+   * returns a new map — so a Promise.all would have every iteration read the
+   * same initial map and race to write back, silently dropping all but the last
+   * segment's signature. Relay ceremonies serialize anyway, so little is lost.
+   */ function mpcSignIntents(tx, access, options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _tx_intents, _tx_intents_keys_toArray, segments, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                segments = (_tx_intents_keys_toArray = (_tx_intents = tx.intents) === null || _tx_intents === void 0 ? void 0 : _tx_intents.keys().toArray()) !== null && _tx_intents_keys_toArray !== void 0 ? _tx_intents_keys_toArray : [];
+                                if (segments.length === 0) return [
+                                    2
+                                ];
+                                _this.logger.info("[Midnight] MPC signing ".concat(segments.length, " intent segment(s)…"));
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _loop = function() {
+                                    var _loop, segment, intent, _options_proofMarker, cloned, sigData, hash, signature, sigBytes, ledgerSig, _i, _iter;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                _loop = function(_i, _iter) {
+                                                    var offerKey = _iter[_i];
+                                                    var offer = cloned[offerKey];
+                                                    if (!offer) return "continue";
+                                                    cloned[offerKey] = offer.addSignatures(offer.inputs.map(function(_, index) {
+                                                        var _offer_signatures_at;
+                                                        return (_offer_signatures_at = offer.signatures.at(index)) !== null && _offer_signatures_at !== void 0 ? _offer_signatures_at : ledgerSig;
+                                                    }));
+                                                };
+                                                segment = _step.value;
+                                                intent = tx.intents.get(segment);
+                                                if (!intent) return [
+                                                    2,
+                                                    "continue"
+                                                ];
+                                                cloned = ledger.Intent.deserialize('signature', (_options_proofMarker = options.proofMarker) !== null && _options_proofMarker !== void 0 ? _options_proofMarker : 'pre-proof', 'pre-binding', intent.serialize());
+                                                sigData = cloned.signatureData(segment);
+                                                hash = createHash('sha256').update(Buffer.from(sigData)).digest('hex');
+                                                return [
+                                                    4,
+                                                    _this.sign({
+                                                        message: hash,
+                                                        accountAddress: access.walletMetadata.accountAddress,
+                                                        chainName: _this.chainName,
+                                                        password: access.password,
+                                                        externalServerKeyShares: access.externalServerKeyShares,
+                                                        walletMetadata: access.walletMetadata,
+                                                        walletOperation: WalletOperation.SIGN_TRANSACTION,
+                                                        // Policy validation runs per signature, so every segment carries the
+                                                        // whole transaction — same shape as BTC's per-input PSBT context.
+                                                        context: _object_spread_props(_object_spread({}, options.baseContext), {
+                                                            midnightTransaction: {
+                                                                serializedTransaction: options.fullTxBase64,
+                                                                networkId: options.networkId
+                                                            }
+                                                        })
+                                                    })
+                                                ];
+                                            case 1:
+                                                signature = _state.sent();
+                                                sigBytes = _instanceof(signature, Uint8Array) ? signature : Buffer.from(String(signature), 'base64');
+                                                ledgerSig = Buffer.from(sigBytes).toString('hex');
+                                                // Preserve any signature already present at an input index; only fill gaps.
+                                                for(_i = 0, _iter = [
+                                                    'guaranteedUnshieldedOffer',
+                                                    'fallibleUnshieldedOffer'
+                                                ]; _i < _iter.length; _i++)_loop(_i, _iter);
+                                                tx.intents = tx.intents.set(segment, cloned);
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                };
+                                _iterator = segments[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_loop())
+                                ];
+                            case 3:
+                                _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
         {
             key: "getMidnightWallets",
             value: /**
@@ -1055,4 +2708,4 @@ var DynamicMidnightWalletClient = /*#__PURE__*/ function(DynamicWalletClient) {
     return DynamicMidnightWalletClient;
 }(DynamicWalletClient);
 
-export { DynamicMidnightWalletClient, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_EXPORT_PRIVATE_KEY, ERROR_IMPORT_PRIVATE_KEY, ERROR_KEYGEN_FAILED, ERROR_SIGN_MESSAGE, MIDNIGHT_NETWORK_IDS, decodeMidnightAddress, deriveMidnightAddress, getNetworkFromAddress, isValidMidnightAddress, resolveMidnightNetworkTag, toXOnlyPublicKeyHex };
+export { DynamicMidnightWalletClient, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_BALANCE_TRANSACTION, ERROR_CREATE_WALLET_ACCOUNT, ERROR_EXPORT_PRIVATE_KEY, ERROR_IMPORT_PRIVATE_KEY, ERROR_KEYGEN_FAILED, ERROR_SIGN_MESSAGE, MIDNIGHT_NETWORK_IDS, decodeMidnightAddress, deriveMidnightAddress, getNetworkFromAddress, isValidMidnightAddress, resolveMidnightNetworkTag, toXOnlyPublicKeyHex };