@dynamic-labs-wallet/midnight 0.0.0 → 0.0.347

package/index.cjs.js

@@ -0,0 +1,3242 @@
+'use strict';
+
+var browser = require('@dynamic-labs-wallet/browser');
+var ledger = require('@midnight-ntwrk/ledger-v8');
+var walletSdkAddressFormat = require('@midnight-ntwrk/wallet-sdk-address-format');
+var walletSdkDustWallet = require('@midnight-ntwrk/wallet-sdk-dust-wallet');
+var walletSdkFacade = require('@midnight-ntwrk/wallet-sdk-facade');
+var walletSdkShielded = require('@midnight-ntwrk/wallet-sdk-shielded');
+var walletSdkUnshieldedWallet = require('@midnight-ntwrk/wallet-sdk-unshielded-wallet');
+var bip32 = require('@scure/bip32');
+var bs58 = require('bs58');
+var bech32 = require('bech32');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ledger__namespace = /*#__PURE__*/_interopNamespaceDefault(ledger);
+var sdkApiCore__namespace = /*#__PURE__*/_interopNamespaceDefault(sdkApiCore);
+
+// Midnight network identifiers.
+// 0 = non-mainnet, 1 = Mainnet — baked into the transaction hash to prevent
+// cross-network replay. Names match the Zswap NetworkId enum / the strings
+// accepted by @midnight-ntwrk/midnight-js-network-id's setNetworkId().
+var MIDNIGHT_NETWORK_IDS = {
+    mainnet: 1,
+    preview: 0,
+    preprod: 0,
+    undeployed: 0
+};
+// Error messages
+var ERROR_ACCOUNT_ADDRESS_REQUIRED = 'Account address is required';
+var ERROR_NETWORK_ID_REQUIRED = 'Network ID is required for Midnight transactions';
+var ERROR_UNKNOWN_NETWORK = 'Unknown Midnight network';
+var ERROR_CREATE_WALLET_ACCOUNT = 'Failed to create Midnight wallet account';
+var ERROR_EXPORT_PRIVATE_KEY = 'Failed to export Midnight private key';
+var ERROR_IMPORT_PRIVATE_KEY = 'Failed to import Midnight private key';
+var ERROR_KEYGEN_FAILED = 'Key generation failed for Midnight wallet';
+var ERROR_SIGN_MESSAGE = 'Failed to sign Midnight message';
+var ERROR_SIGN_TRANSACTION = 'Failed to sign Midnight transaction';
+/**
+ * Resolves a Midnight network name (or `"midnight:<network>"` chainId) to its
+ * numeric network ID (0 for non-mainnet, 1 for mainnet).
+ *
+ * Throws on unrecognized input rather than defaulting — silently falling back
+ * to mainnet would bake the wrong network ID into the transaction hash and
+ * break the replay-protection guarantee. Fail-loud is correct here.
+ *
+ * @param networkOrChainId `mainnet` | `preview` | `preprod` | `undeployed`,
+ *                         or the `midnight:<network>` chainId form.
+ * @throws {Error} ERROR_UNKNOWN_NETWORK when the input doesn't match any
+ *                 recognized network.
+ */ 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>".'));
+};
+
+/**
+ * IndexedDB-backed persistence for Midnight sub-wallet sync state.
+ *
+ * Shielded and Dust sub-wallets support serialize/restore — we cache the
+ * serialized state per accountAddress so re-initializing a wallet (either
+ * after switching away and back, or after a page reload) resumes sync from
+ * the last checkpoint instead of re-scanning the entire chain.
+ *
+ * Storage shape (object store "state", keyed by accountAddress):
+ *   { accountAddress, shielded, dust, updatedAt }
+ *
+ * Security: blobs are stored plaintext, matching Dynamic's existing policy
+ * for locally-cached key material (see the role-keys entries in
+ * localStorage). Protection comes from the iframe's origin isolation, not
+ * from at-rest encryption. If Dynamic decides to tighten the local-storage
+ * policy product-wide (password-derived encryption with AES-GCM), this
+ * module should be upgraded alongside the localStorage role-keys flow as a
+ * single consistent hardening pass.
+ */ function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var DB_NAME = 'dynamic-midnight-wallet-state';
+var DB_VERSION = 1;
+var STORE_NAME = 'state';
+// Normalizes a DOMException | unknown into an Error so promise rejections
+// always carry an Error instance. Object-shaped errors (DOMException, plain
+// objects) are looked up for a `.message` string first so we don't stringify
+// them via Object.prototype.toString (which yields the useless '[object Object]').
+// Exported for direct unit testing of the fallback chain.
+function toError(err, fallbackMessage) {
+    if (_instanceof$1(err, Error)) return err;
+    if (err == null) return new Error(fallbackMessage);
+    if (typeof err === 'string') return new Error(err);
+    if (typeof err === 'number' || typeof err === 'boolean' || (typeof err === "undefined" ? "undefined" : _type_of$1(err)) === 'bigint') {
+        return new Error(String(err));
+    }
+    var message = err.message;
+    if (typeof message === 'string' && message.length > 0) return new Error(message);
+    try {
+        return new Error(JSON.stringify(err));
+    } catch (e) {
+        return new Error(fallbackMessage);
+    }
+}
+var dbPromise = null;
+function openDb() {
+    if (dbPromise) return dbPromise;
+    // On rejection, null the module-level cache so the next caller retries
+    // the open instead of receiving the same rejected promise for the rest of
+    // the session (private-browsing bootup, transient quota errors, etc).
+    // Re-throw so the original caller still sees the rejection.
+    dbPromise = new Promise(function(resolve, reject) {
+        var req = indexedDB.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = function() {
+            var db = req.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                db.createObjectStore(STORE_NAME, {
+                    keyPath: 'accountAddress'
+                });
+            }
+        };
+        req.onsuccess = function() {
+            return resolve(req.result);
+        };
+        req.onerror = function() {
+            return reject(toError(req.error, 'IndexedDB open failed'));
+        };
+    }).catch(function(err) {
+        dbPromise = null;
+        throw err;
+    });
+    return dbPromise;
+}
+function runTransaction(mode, fn) {
+    return _runTransaction.apply(this, arguments);
+}
+function _runTransaction() {
+    _runTransaction = _async_to_generator$1(function(mode, fn) {
+        var db;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        openDb()
+                    ];
+                case 1:
+                    db = _state.sent();
+                    return [
+                        2,
+                        new Promise(function(resolve, reject) {
+                            var tx = db.transaction(STORE_NAME, mode);
+                            var store = tx.objectStore(STORE_NAME);
+                            var req = fn(store);
+                            req.onsuccess = function() {
+                                return resolve(req.result);
+                            };
+                            req.onerror = function() {
+                                return reject(toError(req.error, 'IndexedDB request failed'));
+                            };
+                        })
+                    ];
+            }
+        });
+    });
+    return _runTransaction.apply(this, arguments);
+}
+function getWalletState(accountAddress) {
+    return _getWalletState.apply(this, arguments);
+}
+function _getWalletState() {
+    _getWalletState = _async_to_generator$1(function(accountAddress) {
+        var result;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        runTransaction('readonly', function(store) {
+                            return store.get(accountAddress);
+                        })
+                    ];
+                case 1:
+                    result = _state.sent();
+                    return [
+                        2,
+                        result !== null && result !== void 0 ? result : null
+                    ];
+                case 2:
+                    _state.sent();
+                    // IndexedDB unavailable (private mode, corrupt DB, etc.) — behave as if empty.
+                    return [
+                        2,
+                        null
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _getWalletState.apply(this, arguments);
+}
+function putWalletState(accountAddress, state) {
+    return _putWalletState.apply(this, arguments);
+}
+function _putWalletState() {
+    _putWalletState = _async_to_generator$1(function(accountAddress, state) {
+        var record;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    record = {
+                        accountAddress: accountAddress,
+                        shielded: state.shielded,
+                        dust: state.dust,
+                        updatedAt: Date.now()
+                    };
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        runTransaction('readwrite', function(store) {
+                            return store.put(record);
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _putWalletState.apply(this, arguments);
+}
+function deleteWalletState(accountAddress) {
+    return _deleteWalletState.apply(this, arguments);
+}
+function _deleteWalletState() {
+    _deleteWalletState = _async_to_generator$1(function(accountAddress) {
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        runTransaction('readwrite', function(store) {
+                            return store.delete(accountAddress);
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _deleteWalletState.apply(this, arguments);
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+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 DynamicMidnightWalletClient = /*#__PURE__*/ function(DynamicWalletClient) {
+    _inherits(DynamicMidnightWalletClient, DynamicWalletClient);
+    function DynamicMidnightWalletClient(param, internalOptions) {
+        var environmentId = param.environmentId, authToken = param.authToken, baseApiUrl = param.baseApiUrl, baseMPCRelayApiUrl = param.baseMPCRelayApiUrl, storageKey = param.storageKey, debug = param.debug, featureFlags = param.featureFlags, _param_authMode = param.authMode, authMode = _param_authMode === void 0 ? browser.AuthMode.HEADER : _param_authMode, sdkVersion = param.sdkVersion, forwardMPCClient = param.forwardMPCClient, logger = param.logger;
+        _class_call_check(this, DynamicMidnightWalletClient);
+        var _this;
+        _this = _call_super(this, DynamicMidnightWalletClient, [
+            {
+                environmentId: environmentId,
+                authToken: authToken,
+                baseApiUrl: baseApiUrl,
+                baseMPCRelayApiUrl: baseMPCRelayApiUrl,
+                storageKey: storageKey,
+                debug: debug,
+                featureFlags: featureFlags,
+                authMode: authMode,
+                sdkVersion: sdkVersion,
+                forwardMPCClient: forwardMPCClient,
+                logger: logger
+            },
+            internalOptions
+        ]), _define_property(_this, "chainName", 'MIDNIGHT'), // Keep wallet alive between calls — avoids 90s re-sync per operation.
+        // `diagnosticSub` is the long-lived pending-tx log subscription attached
+        // at init time; we hold onto its handle so account-switch / resetCache
+        // paths can unsubscribe it and release the closure.
+        _define_property(_this, "cachedWallet", null), // Dedup concurrent init calls for the same account. Without this, two
+        // public methods invoked back-to-back (e.g. getPrivateBalance +
+        // submitTransaction) would both miss the cache, both run WalletFacade.init,
+        // and the first wallet's WebSocket + sync threads + diagnostic subscription
+        // would be leaked when the second overwrote `cachedWallet`.
+        _define_property(_this, "pendingInits", new Map());
+        return _this;
+    }
+    _create_class(DynamicMidnightWalletClient, [
+        {
+            key: "persistCachedWalletState",
+            value: /**
+   * Snapshot the current shielded + dust state to IndexedDB so the next
+   * init on this account resumes from this checkpoint. Fire-and-forget —
+   * callers shouldn't await this to avoid adding latency to user actions.
+   *
+   * Option A: ONLY persist when the wallet is in a clean resting state
+   * (no pending-tx entries, no pending UTXOs on any side). If the wallet
+   * has in-flight work, skip the write — we don't want dirty state to
+   * get baked into IndexedDB and trap the user on next reload.
+   *
+   * "Clean" == whatever's persisted can be restored without dragging
+   * stale pending entries forward. If a tx fails or a draft is abandoned,
+   * sync will reconcile on the next load based on what the chain actually
+   * shows, which is always authoritative.
+   */ function persistCachedWalletState() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var cached, _snapshot_pending_all, _snapshot_pending, _snapshot_unshielded, _snapshot_shielded, _snapshot_dust, snapshot, _snapshot_pending_all_length, pendingTxCount, _snapshot_unshielded_pendingCoins, _length, unshieldedPending, _snapshot_shielded_pendingCoins, _length1, shieldedPending, _snapshot_dust_pendingCoins, _length2, dustPending, isDirty, _ref, shielded, dust, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Capture a local reference up-front: the three `await` sites below yield
+                                // to the event loop, during which a concurrent resetCache or account
+                                // switch could null `this.cachedWallet`. Using the local snapshot avoids
+                                // a TypeError-then-warn on every concurrent access, and the final
+                                // identity check prevents writing a stopped wallet's state to IndexedDB
+                                // (which would effectively undo the reset on the next init).
+                                cached = _this.cachedWallet;
+                                if (!cached) return [
+                                    2
+                                ];
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                return [
+                                    4,
+                                    new Promise(function(resolve, reject) {
+                                        // `let` is required: the setTimeout closure references `sub` before the
+                                        // `.subscribe()` call returns, and the callback itself can fire
+                                        // synchronously (TDZ hazard with const).
+                                        // eslint-disable-next-line prefer-const
+                                        var sub;
+                                        var tid = setTimeout(function() {
+                                            sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                            reject(new Error('persist snapshot timeout'));
+                                        }, 5000);
+                                        sub = cached.wallet.state().subscribe(function(s) {
+                                            clearTimeout(tid);
+                                            queueMicrotask(function() {
+                                                return sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                            });
+                                            resolve(s);
+                                        });
+                                    })
+                                ];
+                            case 2:
+                                snapshot = _state.sent();
+                                pendingTxCount = (_snapshot_pending_all_length = snapshot === null || snapshot === void 0 ? void 0 : (_snapshot_pending = snapshot.pending) === null || _snapshot_pending === void 0 ? void 0 : (_snapshot_pending_all = _snapshot_pending.all) === null || _snapshot_pending_all === void 0 ? void 0 : _snapshot_pending_all.length) !== null && _snapshot_pending_all_length !== void 0 ? _snapshot_pending_all_length : 0;
+                                unshieldedPending = (_length = ((_snapshot_unshielded_pendingCoins = snapshot === null || snapshot === void 0 ? void 0 : (_snapshot_unshielded = snapshot.unshielded) === null || _snapshot_unshielded === void 0 ? void 0 : _snapshot_unshielded.pendingCoins) !== null && _snapshot_unshielded_pendingCoins !== void 0 ? _snapshot_unshielded_pendingCoins : []).length) !== null && _length !== void 0 ? _length : 0;
+                                shieldedPending = (_length1 = ((_snapshot_shielded_pendingCoins = snapshot === null || snapshot === void 0 ? void 0 : (_snapshot_shielded = snapshot.shielded) === null || _snapshot_shielded === void 0 ? void 0 : _snapshot_shielded.pendingCoins) !== null && _snapshot_shielded_pendingCoins !== void 0 ? _snapshot_shielded_pendingCoins : []).length) !== null && _length1 !== void 0 ? _length1 : 0;
+                                dustPending = (_length2 = ((_snapshot_dust_pendingCoins = snapshot === null || snapshot === void 0 ? void 0 : (_snapshot_dust = snapshot.dust) === null || _snapshot_dust === void 0 ? void 0 : _snapshot_dust.pendingCoins) !== null && _snapshot_dust_pendingCoins !== void 0 ? _snapshot_dust_pendingCoins : []).length) !== null && _length2 !== void 0 ? _length2 : 0;
+                                isDirty = pendingTxCount > 0 || unshieldedPending > 0 || shieldedPending > 0 || dustPending > 0;
+                                if (isDirty) {
+                                    _this.logger.debug("[Midnight] persist skipped — state is dirty \xb7 " + "pendingTxs=".concat(pendingTxCount, " \xb7 unshieldedPending=").concat(unshieldedPending, " \xb7 ") + "shieldedPending=".concat(shieldedPending, " \xb7 dustPending=").concat(dustPending, ". ") + "IndexedDB retains last clean snapshot.");
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    Promise.all([
+                                        cached.wallet.shielded.serializeState(),
+                                        cached.wallet.dust.serializeState()
+                                    ])
+                                ];
+                            case 3:
+                                _ref = _sliced_to_array.apply(void 0, [
+                                    _state.sent(),
+                                    2
+                                ]), shielded = _ref[0], dust = _ref[1];
+                                // If the cache was swapped or cleared while we were serializing, skip
+                                // the write — otherwise we'd persist the old wallet's snapshot under
+                                // its accountAddress after resetCache (which just deleted that entry)
+                                // or under a newly-stopped account.
+                                if (_this.cachedWallet !== cached) {
+                                    _this.logger.debug('[Midnight] persist skipped — cache changed during serialize');
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    putWalletState(cached.accountAddress, {
+                                        shielded: shielded,
+                                        dust: dust
+                                    })
+                                ];
+                            case 4:
+                                _state.sent();
+                                _this.logger.debug('[Midnight] persisted clean wallet state to IndexedDB');
+                                return [
+                                    3,
+                                    6
+                                ];
+                            case 5:
+                                err = _state.sent();
+                                _this.logger.warn('[Midnight] Failed to persist wallet state:', err);
+                                return [
+                                    3,
+                                    6
+                                ];
+                            case 6:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "createWalletAccount",
+            value: function createWalletAccount(param) {
+                var thresholdSignatureScheme = param.thresholdSignatureScheme, _param_password = param.password, password = _param_password === void 0 ? undefined : _param_password, onError = param.onError, signedSessionId = param.signedSessionId;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var ceremonyCeremonyCompleteResolver, serverAccountAddress, ceremonyCompletePromise, _ref, publicKeyHex, clientKeyShares, accountAddress, pubKeyBytes, roleKeys, shieldedSecretKeys, shieldedAddr, shieldedBech32m, dustBech32m, dustSecretKey, dustAddr, toHex, correctAddresses, wallet, addrError, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    11,
+                                    ,
+                                    12
+                                ]);
+                                ceremonyCompletePromise = new Promise(function(resolve) {
+                                    ceremonyCeremonyCompleteResolver = resolve;
+                                });
+                                return [
+                                    4,
+                                    _this.keyGen({
+                                        chainName: _this.chainName,
+                                        thresholdSignatureScheme: thresholdSignatureScheme,
+                                        onError: onError,
+                                        onCeremonyComplete: function(accountAddress, walletId) {
+                                            var chainConfig = browser.getMPCChainConfig(_this.chainName);
+                                            serverAccountAddress = accountAddress;
+                                            _this.initializeWalletMapEntry({
+                                                accountAddress: accountAddress,
+                                                walletId: walletId,
+                                                chainName: _this.chainName,
+                                                thresholdSignatureScheme: thresholdSignatureScheme,
+                                                derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map(function(value, index) {
+                                                    return [
+                                                        index,
+                                                        value
+                                                    ];
+                                                })))
+                                            });
+                                            ceremonyCeremonyCompleteResolver(undefined);
+                                        },
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), publicKeyHex = _ref.rawPublicKey, clientKeyShares = _ref.clientKeyShares;
+                                return [
+                                    4,
+                                    ceremonyCompletePromise
+                                ];
+                            case 2:
+                                _state.sent();
+                                if (!publicKeyHex || !clientKeyShares) {
+                                    throw new Error(ERROR_KEYGEN_FAILED);
+                                }
+                                // Server uses ledger.addressFromKey() (Poseidon hash of public key) —
+                                // we can't run it in the browser because the hashing is WASM-only.
+                                accountAddress = serverAccountAddress;
+                                return [
+                                    4,
+                                    _this.setClientKeySharesToStorage({
+                                        accountAddress: accountAddress,
+                                        clientKeyShares: clientKeyShares
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    4,
+                                    _this.storeEncryptedBackupByWallet({
+                                        accountAddress: accountAddress,
+                                        clientKeyShares: clientKeyShares,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 4:
+                                _state.sent();
+                                pubKeyBytes = Buffer.from(publicKeyHex, 'hex');
+                                _state.label = 5;
+                            case 5:
+                                _state.trys.push([
+                                    5,
+                                    9,
+                                    ,
+                                    10
+                                ]);
+                                _this.logger.info('[Midnight] Computing shielded and dust addresses client-side');
+                                return [
+                                    4,
+                                    _this.getRoleKeys(accountAddress, {
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 6:
+                                roleKeys = _state.sent();
+                                shieldedSecretKeys = ledger__namespace.ZswapSecretKeys.fromSeed(new Uint8Array(Buffer.from(roleKeys.shielded, 'hex')));
+                                shieldedAddr = new walletSdkAddressFormat.ShieldedAddress(new walletSdkAddressFormat.ShieldedCoinPublicKey(Buffer.from(shieldedSecretKeys.coinPublicKey, 'hex')), new walletSdkAddressFormat.ShieldedEncryptionPublicKey(Buffer.from(shieldedSecretKeys.encryptionPublicKey, 'hex')));
+                                shieldedBech32m = walletSdkAddressFormat.MidnightBech32m.encode('preview', shieldedAddr).toString();
+                                try {
+                                    dustSecretKey = ledger__namespace.DustSecretKey.fromSeed(new Uint8Array(Buffer.from(roleKeys.dust, 'hex')));
+                                    dustAddr = new walletSdkAddressFormat.DustAddress(dustSecretKey.publicKey);
+                                    dustBech32m = walletSdkAddressFormat.MidnightBech32m.encode('preview', dustAddr).toString();
+                                } catch (dustErr) {
+                                    _this.logger.warn('[Midnight] Dust address encoding failed (skipping):', dustErr);
+                                }
+                                toHex = function(val) {
+                                    if (typeof val === 'string') return val;
+                                    if (_instanceof(val, Uint8Array)) return Buffer.from(val).toString('hex');
+                                    if ((typeof val === "undefined" ? "undefined" : _type_of(val)) === 'bigint') return val.toString(16);
+                                    return String(val);
+                                };
+                                correctAddresses = [
+                                    {
+                                        address: accountAddress,
+                                        type: 'midnight_unshielded',
+                                        publicKey: toHex(publicKeyHex)
+                                    },
+                                    {
+                                        address: shieldedBech32m,
+                                        type: 'midnight_shielded',
+                                        publicKey: toHex(shieldedSecretKeys.coinPublicKey)
+                                    }
+                                ];
+                                if (dustBech32m && dustSecretKey) {
+                                    correctAddresses.push({
+                                        address: dustBech32m,
+                                        type: 'midnight_dust',
+                                        publicKey: toHex(dustSecretKey.publicKey)
+                                    });
+                                }
+                                _this.logger.info('[Midnight] Updating additional addresses with correct derivation');
+                                return [
+                                    4,
+                                    _this.getWallet({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 7:
+                                wallet = _state.sent();
+                                return [
+                                    4,
+                                    _this.apiClient.updateAdditionalAddresses({
+                                        walletId: wallet.walletId,
+                                        additionalAddresses: correctAddresses
+                                    })
+                                ];
+                            case 8:
+                                _state.sent();
+                                _this.logger.info('[Midnight] Additional addresses updated');
+                                return [
+                                    3,
+                                    10
+                                ];
+                            case 9:
+                                addrError = _state.sent();
+                                // Non-fatal — wallet works without correct addresses, just display is wrong
+                                _this.logger.error('[Midnight] FAILED TO COMPUTE/UPDATE ADDRESSES:', addrError);
+                                _this.logger.warn('[Midnight] Failed to update additional addresses (non-fatal)', addrError);
+                                return [
+                                    3,
+                                    10
+                                ];
+                            case 10:
+                                return [
+                                    2,
+                                    {
+                                        accountAddress: accountAddress,
+                                        publicKeyHex: publicKeyHex,
+                                        rawPublicKey: new Uint8Array(pubKeyBytes)
+                                    }
+                                ];
+                            case 11:
+                                error = _state.sent();
+                                // Re-throw password mismatch errors without wrapping
+                                if (_instanceof(error, Error) && error.message === browser.ERROR_PASSWORD_MISMATCH) {
+                                    throw error;
+                                }
+                                _this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+                                throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+                            case 12:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "signMessage",
+            value: function signMessage(param) {
+                var message = param.message, accountAddress = param.accountAddress, _param_password = param.password, password = _param_password === void 0 ? undefined : _param_password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, context = param.context, onError = param.onError;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var messageHex, resolvedContext, signature, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!accountAddress) {
+                                    throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                                }
+                                return [
+                                    4,
+                                    _this.verifyPassword({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                // The signing API expects hex; policy validation needs the original
+                                // bytes. Send hex on the wire, keep the original on the context.
+                                messageHex = Buffer.from(message).toString('hex');
+                                // Cast: SignMessageContext doesn't declare chain-specific fields.
+                                resolvedContext = _object_spread_props(_object_spread({}, context), {
+                                    midnightMessage: message
+                                });
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    _this.sign({
+                                        message: messageHex,
+                                        accountAddress: accountAddress,
+                                        chainName: _this.chainName,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        context: resolvedContext,
+                                        onError: onError
+                                    })
+                                ];
+                            case 3:
+                                signature = _state.sent();
+                                return [
+                                    2,
+                                    Buffer.from(signature).toString('base64')
+                                ];
+                            case 4:
+                                error = _state.sent();
+                                _this.logger.error(ERROR_SIGN_MESSAGE, error);
+                                throw new Error(ERROR_SIGN_MESSAGE);
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "signTransaction",
+            value: /**
+   * Sign + finalize (prove) an unsigned Midnight transaction. Unshielded
+   * segments are MPC-signed via BIP-340; shielded/dust proving is delegated
+   * to the facade's proof server.
+   *
+   * Side effect: finalizeRecipe mutates wallet state (adds a pending-tx
+   * entry). If the caller never calls submitTransaction, that entry sits
+   * until the next re-sync drops it.
+   */ function signTransaction(param) {
+                var senderAddress = param.senderAddress, transaction = param.transaction, _param_password = param.password, password = _param_password === void 0 ? undefined : _param_password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken, networkId = param.networkId, context = param.context, onError = param.onError;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var resolvedNetworkId, wallet, txBytes, unsignedTx, signedRecipe, finalized, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!senderAddress) {
+                                    throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                                }
+                                return [
+                                    4,
+                                    _this.verifyPassword({
+                                        accountAddress: senderAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                if (networkId === undefined) {
+                                    throw new Error(ERROR_NETWORK_ID_REQUIRED);
+                                }
+                                resolvedNetworkId = typeof networkId === 'number' ? networkId : getNetworkIdFromChainId(networkId);
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    6,
+                                    ,
+                                    7
+                                ]);
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('signTransaction', {
+                                        accountAddress: senderAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 3:
+                                wallet = _state.sent().wallet;
+                                txBytes = Buffer.from(transaction, 'base64');
+                                unsignedTx = ledger__namespace.Transaction.deserialize('signature', 'pre-proof', 'pre-binding', new Uint8Array(txBytes));
+                                // Context carries the full unsigned tx so wallet-service policy can
+                                // validate against the whole transaction on each per-segment signature
+                                // (same pattern as BTC PSBT per-input context).
+                                return [
+                                    4,
+                                    _this.mpcSignIntents(unsignedTx, {
+                                        accountAddress: senderAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken,
+                                        fullTxBase64: transaction,
+                                        networkId: resolvedNetworkId,
+                                        baseContext: context,
+                                        proofMarker: 'pre-proof'
+                                    })
+                                ];
+                            case 4:
+                                _state.sent();
+                                signedRecipe = {
+                                    type: 'UNPROVEN_TRANSACTION',
+                                    transaction: unsignedTx
+                                };
+                                _this.logger.info('[Midnight] signTransaction: finalizing (ZK prove)...');
+                                return [
+                                    4,
+                                    wallet.finalizeRecipe(signedRecipe)
+                                ];
+                            case 5:
+                                finalized = _state.sent();
+                                return [
+                                    2,
+                                    Buffer.from(finalized.serialize()).toString('base64')
+                                ];
+                            case 6:
+                                error = _state.sent();
+                                _this.logger.error(ERROR_SIGN_TRANSACTION, error);
+                                onError === null || onError === void 0 ? void 0 : onError(error);
+                                throw _instanceof(error, Error) ? error : new Error(ERROR_SIGN_TRANSACTION);
+                            case 7:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "exportPrivateKey",
+            value: function exportPrivateKey(param) {
+                var accountAddress = param.accountAddress, _param_password = param.password, password = _param_password === void 0 ? undefined : _param_password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var mpcSigner, wallet, reconstructedKeyShare, exportId, data, keyExportRaw, exportStr, xprvBytes, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Matches the EVM/BTC exportPrivateKey pattern: verify the password OUTSIDE
+                                // the try-catch so a password-protected wallet can't be exported without
+                                // the right one AND the specific ERROR_PASSWORD_MISMATCH propagates to the
+                                // UI — wrapping it as ERROR_EXPORT_PRIVATE_KEY would hide which prompt to
+                                // show the user.
+                                return [
+                                    4,
+                                    _this.verifyPassword({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    8,
+                                    ,
+                                    9
+                                ]);
+                                // Fetch the master xprv (not the wallet-path-derived key) so derivations
+                                // here match what the iframe's HDWallet produces from the same root.
+                                mpcSigner = browser.getMPCSigner({
+                                    chainName: _this.chainName,
+                                    baseRelayUrl: _this.baseMPCRelayApiUrl
+                                });
+                                return [
+                                    4,
+                                    _this.getWallet({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        walletOperation: browser.WalletOperation.EXPORT_PRIVATE_KEY,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 3:
+                                wallet = _state.sent();
+                                return [
+                                    4,
+                                    _this.getReconstructedKeyShare(accountAddress, mpcSigner)
+                                ];
+                            case 4:
+                                reconstructedKeyShare = _state.sent();
+                                return [
+                                    4,
+                                    _this.getExportId({
+                                        chainName: _this.chainName,
+                                        clientKeyShare: reconstructedKeyShare
+                                    })
+                                ];
+                            case 5:
+                                exportId = _state.sent();
+                                return [
+                                    4,
+                                    _this.apiClient.exportKey({
+                                        walletId: wallet.walletId,
+                                        exportId: exportId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 6:
+                                data = _state.sent();
+                                return [
+                                    4,
+                                    _this.performMPCExport(mpcSigner, reconstructedKeyShare, data.roomId, exportId, accountAddress, _this.chainName)
+                                ];
+                            case 7:
+                                keyExportRaw = _state.sent();
+                                if (!keyExportRaw) {
+                                    throw new Error('MPC export returned no key');
+                                }
+                                // keyExportRaw is a BIP32 xprv in base58; bytes 46-78 are the 32-byte
+                                // master private key per the xprv serialization format.
+                                exportStr = typeof keyExportRaw === 'string' ? keyExportRaw : String(keyExportRaw);
+                                xprvBytes = bs58.decode(exportStr);
+                                return [
+                                    2,
+                                    Buffer.from(xprvBytes.slice(46, 78)).toString('hex')
+                                ];
+                            case 8:
+                                error = _state.sent();
+                                _this.logger.error(ERROR_EXPORT_PRIVATE_KEY, error);
+                                throw new Error(ERROR_EXPORT_PRIVATE_KEY);
+                            case 9:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "importPrivateKey",
+            value: function importPrivateKey(param) {
+                var privateKey = param.privateKey, chainName = param.chainName, thresholdSignatureScheme = param.thresholdSignatureScheme, _param_password = param.password, password = _param_password === void 0 ? undefined : _param_password, signedSessionId = param.signedSessionId, onError = param.onError; param.publicAddressCheck; var legacyWalletId = param.legacyWalletId;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var ceremonyCeremonyCompleteResolver, serverAccountAddress, ceremonyCompletePromise, formattedPrivateKey, _ref, rawPublicKey, clientKeyShares, accountAddress, pubKeyBytes, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                ceremonyCompletePromise = new Promise(function(resolve) {
+                                    ceremonyCeremonyCompleteResolver = resolve;
+                                });
+                                formattedPrivateKey = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
+                                return [
+                                    4,
+                                    _this.importRawPrivateKey({
+                                        chainName: chainName,
+                                        thresholdSignatureScheme: thresholdSignatureScheme,
+                                        privateKey: formattedPrivateKey,
+                                        onCeremonyComplete: function(accountAddress, walletId) {
+                                            serverAccountAddress = accountAddress;
+                                            _this.initializeWalletMapEntry({
+                                                accountAddress: accountAddress,
+                                                walletId: walletId,
+                                                chainName: _this.chainName,
+                                                thresholdSignatureScheme: thresholdSignatureScheme
+                                            });
+                                            ceremonyCeremonyCompleteResolver(undefined);
+                                        },
+                                        onError: onError,
+                                        legacyWalletId: legacyWalletId,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), rawPublicKey = _ref.rawPublicKey, clientKeyShares = _ref.clientKeyShares;
+                                return [
+                                    4,
+                                    ceremonyCompletePromise
+                                ];
+                            case 2:
+                                _state.sent();
+                                if (!rawPublicKey || !clientKeyShares) {
+                                    throw new Error(ERROR_IMPORT_PRIVATE_KEY);
+                                }
+                                accountAddress = serverAccountAddress;
+                                return [
+                                    4,
+                                    _this.setClientKeySharesToStorage({
+                                        accountAddress: accountAddress,
+                                        clientKeyShares: clientKeyShares
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    4,
+                                    _this.storeEncryptedBackupByWallet({
+                                        accountAddress: accountAddress,
+                                        clientKeyShares: clientKeyShares,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 4:
+                                _state.sent();
+                                pubKeyBytes = Buffer.from(rawPublicKey, 'hex');
+                                return [
+                                    2,
+                                    {
+                                        accountAddress: accountAddress,
+                                        publicKeyHex: rawPublicKey,
+                                        rawPublicKey: new Uint8Array(pubKeyBytes),
+                                        clientKeyShares: clientKeyShares
+                                    }
+                                ];
+                            case 5:
+                                error = _state.sent();
+                                // Password mismatch must propagate so the UI can re-prompt — wrapping it
+                                // as ERROR_IMPORT_PRIVATE_KEY would hide which error the UI is meant to
+                                // recover from. Same pattern as createWalletAccount.
+                                if (_instanceof(error, Error) && error.message === browser.ERROR_PASSWORD_MISMATCH) {
+                                    throw error;
+                                }
+                                _this.logger.error(ERROR_IMPORT_PRIVATE_KEY, error);
+                                onError === null || onError === void 0 ? void 0 : onError(error);
+                                throw new Error(ERROR_IMPORT_PRIVATE_KEY);
+                            case 6:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getPublicKeyFromPrivateKey",
+            value: function getPublicKeyFromPrivateKey(privateKeyHex) {
+                try {
+                    var privateKeyBytes = Buffer.from(privateKeyHex, 'hex');
+                    if (privateKeyBytes.length !== 32) {
+                        throw new Error("Invalid private key length: ".concat(privateKeyBytes.length, ", expected 32"));
+                    }
+                    return ledger__namespace.signatureVerifyingKey(privateKeyHex);
+                } catch (error) {
+                    // Debug-level only: this is a caller-input validation failure, not a
+                    // system error. The full error is re-thrown, so callers can surface or
+                    // inspect it themselves — no need to duplicate it at a higher level
+                    // where it could land in production logs.
+                    this.logger.debug('[Midnight] getPublicKeyFromPrivateKey failed', error);
+                    throw error;
+                }
+            }
+        },
+        {
+            key: "getMidnightWallets",
+            value: function getMidnightWallets() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var wallets, midnightWallets;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.getWallets()
+                                ];
+                            case 1:
+                                wallets = _state.sent();
+                                // chainName on the wallet-map entry is uppercase (matches this.chainName
+                                // and all other chain clients: 'EVM', 'SVM', 'BTC', …). Filtering on
+                                // lowercase 'midnight' here always returned an empty array.
+                                midnightWallets = wallets.filter(function(wallet) {
+                                    return wallet.chainName === _this.chainName;
+                                });
+                                return [
+                                    2,
+                                    midnightWallets
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getRoleKeys",
+            value: /**
+   * Get or derive Midnight role keys (cached in storage).
+   * Calls existing exportKey internally - no new MPC flow.
+   * Keys: unshielded (NightExternal), shielded (Zswap), dust.
+   */ function getRoleKeys(accountAddress, param) {
+                var password = param.password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _this_cachedWallet, mpcSigner, wallet, reconstructedKeyShare, exportId, data, keyExportRaw, exportStr, master, unshieldedNode, shieldedNode, dustNode, roleKeys;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // In-memory cache: reuse role keys if the caller already booted this wallet
+                                // in the current session. initMidnightWallet sets this.cachedWallet after
+                                // its first call to getRoleKeys, so subsequent fresh-inits for the same
+                                // account can skip the expensive MPC export.
+                                if (((_this_cachedWallet = _this.cachedWallet) === null || _this_cachedWallet === void 0 ? void 0 : _this_cachedWallet.accountAddress) === accountAddress) {
+                                    return [
+                                        2,
+                                        _this.cachedWallet.roleKeys
+                                    ];
+                                }
+                                // We deliberately do NOT persist role keys (private BIP32-derived keys
+                                // for shielded/dust/unshielded roles) to localStorage. Plaintext browser
+                                // storage of secret key material is a known exfiltration risk (XSS,
+                                // malicious extensions). The cost of MPC-re-exporting on each session
+                                // start (~few seconds) is acceptable vs. leaking the key material to
+                                // disk. A future hardening pass could add a password-derived AES-GCM
+                                // encryption layer to persist them securely across reloads.
+                                _this.logger.info('[Midnight] Exporting root key for role derivation', {
+                                    accountAddress: accountAddress
+                                });
+                                mpcSigner = browser.getMPCSigner({
+                                    chainName: _this.chainName,
+                                    baseRelayUrl: _this.baseMPCRelayApiUrl
+                                });
+                                return [
+                                    4,
+                                    _this.getWallet({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        walletOperation: browser.WalletOperation.EXPORT_PRIVATE_KEY,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                wallet = _state.sent();
+                                return [
+                                    4,
+                                    _this.getReconstructedKeyShare(accountAddress, mpcSigner)
+                                ];
+                            case 2:
+                                reconstructedKeyShare = _state.sent();
+                                return [
+                                    4,
+                                    _this.getExportId({
+                                        chainName: _this.chainName,
+                                        clientKeyShare: reconstructedKeyShare
+                                    })
+                                ];
+                            case 3:
+                                exportId = _state.sent();
+                                return [
+                                    4,
+                                    _this.apiClient.exportKey({
+                                        walletId: wallet.walletId,
+                                        exportId: exportId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 4:
+                                data = _state.sent();
+                                return [
+                                    4,
+                                    _this.performMPCExport(mpcSigner, reconstructedKeyShare, data.roomId, exportId, accountAddress, _this.chainName)
+                                ];
+                            case 5:
+                                keyExportRaw = _state.sent();
+                                if (!keyExportRaw) {
+                                    throw new Error('MPC export returned no key');
+                                }
+                                // keyExportRaw is a base58 BIP32 xprv (e.g., xprv9s21ZrQH143K3...) — the MPC master xprv.
+                                // We derive role keys via BIP32 directly on this master so our derivations match what the
+                                // server does (BIP340.derivePrivateKeyFromXpriv) and what `verify-from-xprv.js` produces.
+                                exportStr = typeof keyExportRaw === 'string' ? keyExportRaw : String(keyExportRaw);
+                                master = bip32.HDKey.fromExtendedKey(exportStr);
+                                // Unshielded: NON-hardened to match the server's MPC signing path (Sodot's
+                                // derivePrivateKeyFromXpriv is non-hardened-only). If we used the hardened
+                                // Midnight-canonical path here, the UnshieldedWallet facade would track a
+                                // different address than the one the server signs for, and balances/txns
+                                // would silently diverge.
+                                // Shielded + Dust: hardened Midnight-canonical paths (m/44'/2400'/0'/role/0),
+                                // matching @midnight-ntwrk/wallet-sdk-hd. Those roles are signed entirely
+                                // client-side, so Sodot's non-hardened constraint doesn't apply.
+                                unshieldedNode = master.derive('m/44/2400/0/0/0');
+                                shieldedNode = master.derive("m/44'/2400'/0'/3/0");
+                                dustNode = master.derive("m/44'/2400'/0'/2/0");
+                                if (!unshieldedNode.privateKey || !shieldedNode.privateKey || !dustNode.privateKey) {
+                                    throw new Error('BIP32 derivation returned null privateKey');
+                                }
+                                roleKeys = {
+                                    unshielded: Buffer.from(unshieldedNode.privateKey).toString('hex'),
+                                    shielded: Buffer.from(shieldedNode.privateKey).toString('hex'),
+                                    dust: Buffer.from(dustNode.privateKey).toString('hex')
+                                };
+                                _this.logger.info('[Midnight] Role keys derived (in-memory only)', {
+                                    accountAddress: accountAddress
+                                });
+                                return [
+                                    2,
+                                    roleKeys
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "initMidnightWallet",
+            value: function initMidnightWallet(label, mpcParams) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var accountAddress, inFlight, initPromise;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                accountAddress = mpcParams.accountAddress;
+                                // If another init for this same account is in flight, return its promise
+                                // instead of kicking off a second, redundant WalletFacade.init.
+                                inFlight = _this.pendingInits.get(accountAddress);
+                                if (inFlight) {
+                                    _this.logger.info("[Midnight] ".concat(label, ": joining in-flight init for ").concat(accountAddress));
+                                    return [
+                                        2,
+                                        inFlight
+                                    ];
+                                }
+                                initPromise = _this.runMidnightWalletInit(label, mpcParams);
+                                _this.pendingInits.set(accountAddress, initPromise);
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    ,
+                                    3,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    initPromise
+                                ];
+                            case 2:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 3:
+                                _this.pendingInits.delete(accountAddress);
+                                return [
+                                    7
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "runMidnightWalletInit",
+            value: function runMidnightWalletInit(label, mpcParams) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _this_cachedWallet, roleKeys, accountAddress, state, _this_cachedWallet_diagnosticSub, shieldedSecretKeys, dustSecretKey, unshieldedKeystore, config, savedState, wallet, syncStart, lastLogTime, fmtSide, state1, err, lastPendingCount, lastPendingSig, diagnosticSub;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.getRoleKeys(mpcParams.accountAddress, mpcParams)
+                                ];
+                            case 1:
+                                roleKeys = _state.sent();
+                                accountAddress = mpcParams.accountAddress;
+                                if (!(((_this_cachedWallet = _this.cachedWallet) === null || _this_cachedWallet === void 0 ? void 0 : _this_cachedWallet.accountAddress) === accountAddress)) return [
+                                    3,
+                                    3
+                                ];
+                                _this.logger.info("[Midnight] ".concat(label, ": reusing cached wallet (background sync active)"));
+                                return [
+                                    4,
+                                    new Promise(function(resolve, reject) {
+                                        // `sub` must be declared as `let` because the callback can fire
+                                        // synchronously during `.subscribe()` (the cached wallet is already
+                                        // synced, so the state observable emits immediately on subscription).
+                                        // If we used `const sub = ...subscribe(...)`, the callback would hit
+                                        // `sub` before the binding was initialized (TDZ error).
+                                        // eslint-disable-next-line prefer-const
+                                        var sub;
+                                        var tid = setTimeout(function() {
+                                            sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                            reject(new Error('Wallet re-sync timeout'));
+                                        }, 30000);
+                                        sub = _this.cachedWallet.wallet.state().subscribe(function(s) {
+                                            if (s.isSynced) {
+                                                clearTimeout(tid);
+                                                // Defer to a microtask so `sub` is definitely assigned whether the
+                                                // emission is synchronous or async.
+                                                queueMicrotask(function() {
+                                                    return sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                                });
+                                                resolve(s);
+                                            }
+                                        });
+                                    })
+                                ];
+                            case 2:
+                                state = _state.sent();
+                                return [
+                                    2,
+                                    _object_spread_props(_object_spread({}, _this.cachedWallet), {
+                                        state: state
+                                    })
+                                ];
+                            case 3:
+                                if (!_this.cachedWallet) return [
+                                    3,
+                                    8
+                                ];
+                                _this.logger.info("[Midnight] ".concat(label, ": stopping previous wallet (account changed)"));
+                                try {
+                                    ;
+                                    (_this_cachedWallet_diagnosticSub = _this.cachedWallet.diagnosticSub) === null || _this_cachedWallet_diagnosticSub === void 0 ? void 0 : _this_cachedWallet_diagnosticSub.unsubscribe();
+                                } catch (e) {
+                                /* ignore */ }
+                                _state.label = 4;
+                            case 4:
+                                _state.trys.push([
+                                    4,
+                                    6,
+                                    ,
+                                    7
+                                ]);
+                                return [
+                                    4,
+                                    _this.cachedWallet.wallet.stop()
+                                ];
+                            case 5:
+                                _state.sent();
+                                return [
+                                    3,
+                                    7
+                                ];
+                            case 6:
+                                _state.sent();
+                                return [
+                                    3,
+                                    7
+                                ];
+                            case 7:
+                                _this.cachedWallet = null;
+                                _state.label = 8;
+                            case 8:
+                                shieldedSecretKeys = ledger__namespace.ZswapSecretKeys.fromSeed(new Uint8Array(Buffer.from(roleKeys.shielded, 'hex')));
+                                dustSecretKey = ledger__namespace.DustSecretKey.fromSeed(new Uint8Array(Buffer.from(roleKeys.dust, 'hex')));
+                                unshieldedKeystore = walletSdkUnshieldedWallet.createKeystore(new Uint8Array(Buffer.from(roleKeys.unshielded, 'hex')), 'preview');
+                                config = {
+                                    networkId: 'preview',
+                                    costParameters: {
+                                        feeBlocksMargin: 5
+                                    },
+                                    relayURL: new URL('wss://rpc.preview.midnight.network'),
+                                    provingServerUrl: new URL('http://localhost:6300'),
+                                    indexerClientConnection: {
+                                        indexerHttpUrl: 'https://indexer.preview.midnight.network/api/v4/graphql',
+                                        indexerWsUrl: 'wss://indexer.preview.midnight.network/api/v4/graphql/ws'
+                                    },
+                                    txHistoryStorage: new walletSdkUnshieldedWallet.NoOpTransactionHistoryStorage()
+                                };
+                                return [
+                                    4,
+                                    getWalletState(accountAddress)
+                                ];
+                            case 9:
+                                savedState = _state.sent();
+                                if (savedState) {
+                                    _this.logger.info("[Midnight] ".concat(label, ": found persisted state — resuming sync from checkpoint"));
+                                } else {
+                                    _this.logger.info("[Midnight] ".concat(label, ": no persisted state — cold sync from genesis"));
+                                }
+                                _this.logger.info("[Midnight] ".concat(label, ": initializing wallet..."));
+                                return [
+                                    4,
+                                    walletSdkFacade.WalletFacade.init({
+                                        configuration: config,
+                                        shielded: function(cfg) {
+                                            return savedState ? walletSdkShielded.ShieldedWallet(cfg).restore(savedState.shielded) : walletSdkShielded.ShieldedWallet(cfg).startWithSecretKeys(shieldedSecretKeys);
+                                        },
+                                        unshielded: function(cfg) {
+                                            return walletSdkUnshieldedWallet.UnshieldedWallet(cfg).startWithPublicKey(walletSdkUnshieldedWallet.PublicKey.fromKeyStore(unshieldedKeystore));
+                                        },
+                                        dust: function(cfg) {
+                                            return savedState ? walletSdkDustWallet.DustWallet(cfg).restore(savedState.dust) : walletSdkDustWallet.DustWallet(cfg).startWithSecretKey(dustSecretKey, ledger__namespace.LedgerParameters.initialParameters().dust);
+                                        }
+                                    })
+                                ];
+                            case 10:
+                                wallet = _state.sent();
+                                return [
+                                    4,
+                                    wallet.start(shieldedSecretKeys, dustSecretKey)
+                                ];
+                            case 11:
+                                _state.sent();
+                                _this.logger.debug("[Midnight] ".concat(label, ": syncing..."));
+                                syncStart = Date.now();
+                                lastLogTime = 0;
+                                // Per-side sync-progress summary. Fields are bigints; `gap` is how many
+                                // updates still need to be applied to reach the latest relevant index
+                                // (not the chain tip — `highestRelevantIndex` is what matters for balance).
+                                // Read the progress object the SDK itself uses for isSynced. For shielded
+                                // and dust it lives at `side.state.progress`; for unshielded it's
+                                // `side.progress`. Fall back across both to be safe.
+                                fmtSide = function(side) {
+                                    var _side_state;
+                                    var _side_state_progress;
+                                    var p = (_side_state_progress = side === null || side === void 0 ? void 0 : (_side_state = side.state) === null || _side_state === void 0 ? void 0 : _side_state.progress) !== null && _side_state_progress !== void 0 ? _side_state_progress : side === null || side === void 0 ? void 0 : side.progress;
+                                    if (!p) return 'n/a';
+                                    var _p_appliedIndex;
+                                    var applied = (_p_appliedIndex = p.appliedIndex) !== null && _p_appliedIndex !== void 0 ? _p_appliedIndex : 0n;
+                                    var _p_highestRelevantIndex;
+                                    var highestRelevant = (_p_highestRelevantIndex = p.highestRelevantIndex) !== null && _p_highestRelevantIndex !== void 0 ? _p_highestRelevantIndex : 0n;
+                                    var _p_highestRelevantWalletIndex;
+                                    var highestRelevantWallet = (_p_highestRelevantWalletIndex = p.highestRelevantWalletIndex) !== null && _p_highestRelevantWalletIndex !== void 0 ? _p_highestRelevantWalletIndex : 0n;
+                                    var _p_highestIndex;
+                                    var highest = (_p_highestIndex = p.highestIndex) !== null && _p_highestIndex !== void 0 ? _p_highestIndex : 0n;
+                                    var connected = p.isConnected ? '✓' : '✗';
+                                    var done = '?';
+                                    if (typeof p.isStrictlyComplete === 'function') {
+                                        done = p.isStrictlyComplete() ? '✓' : '✗';
+                                    }
+                                    return "done=".concat(done, " \xb7 applied=").concat(applied, " \xb7 hrw=").concat(highestRelevantWallet, " \xb7 hr=").concat(highestRelevant, " \xb7 tip=").concat(highest, " \xb7 ws=").concat(connected);
+                                };
+                                _state.label = 12;
+                            case 12:
+                                _state.trys.push([
+                                    12,
+                                    14,
+                                    ,
+                                    19
+                                ]);
+                                return [
+                                    4,
+                                    new Promise(function(resolve, reject) {
+                                        // `let` + optional chaining + queueMicrotask — same TDZ-safe pattern used
+                                        // in the cached-wallet, persist, and snapshot paths. Restoring from a
+                                        // checkpoint that's already at chain tip makes `.subscribe(...)` fire the
+                                        // callback synchronously before the `sub` binding initializes.
+                                        // eslint-disable-next-line prefer-const
+                                        var sub;
+                                        var timeoutId = setTimeout(function() {
+                                            sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                            reject(new Error('Wallet sync timeout'));
+                                        }, 300000);
+                                        sub = wallet.state().subscribe(function(s) {
+                                            var now = Date.now();
+                                            if (now - lastLogTime > 5000) {
+                                                lastLogTime = now;
+                                                _this.logger.debug("[Midnight] ".concat(label, ": sync @ ").concat(((now - syncStart) / 1000).toFixed(1), "s \xb7 ") + "isSynced=".concat(s.isSynced, " \xb7 ") + "shielded=".concat(fmtSide(s.shielded), " \xb7 ") + "unshielded=".concat(fmtSide(s.unshielded), " \xb7 ") + "dust=".concat(fmtSide(s.dust)));
+                                            }
+                                            if (s.isSynced) {
+                                                clearTimeout(timeoutId);
+                                                queueMicrotask(function() {
+                                                    return sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                                });
+                                                _this.logger.debug("[Midnight] ".concat(label, ": synced in ").concat(((Date.now() - syncStart) / 1000).toFixed(1), "s \xb7 ") + "shielded=".concat(fmtSide(s.shielded), " \xb7 ") + "unshielded=".concat(fmtSide(s.unshielded), " \xb7 ") + "dust=".concat(fmtSide(s.dust)));
+                                                resolve(s);
+                                            }
+                                        });
+                                    })
+                                ];
+                            case 13:
+                                state1 = _state.sent();
+                                return [
+                                    3,
+                                    19
+                                ];
+                            case 14:
+                                err = _state.sent();
+                                _state.label = 15;
+                            case 15:
+                                _state.trys.push([
+                                    15,
+                                    17,
+                                    ,
+                                    18
+                                ]);
+                                return [
+                                    4,
+                                    wallet.stop()
+                                ];
+                            case 16:
+                                _state.sent();
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 17:
+                                _state.sent();
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 18:
+                                throw err;
+                            case 19:
+                                // Diagnostic: track pending-tx transitions so we can observe TTL
+                                // auto-revert (entry flips from result=undefined → result.status='FAILURE'
+                                // then disappears on the next tick). Subscription handle is kept on the
+                                // cachedWallet so cleanup paths (account-switch, resetCache) can
+                                // unsubscribe it — otherwise its closure pins `this`, `wallet`, and the
+                                // full log-format state for the lifetime of the client.
+                                lastPendingCount = -1;
+                                lastPendingSig = '';
+                                diagnosticSub = wallet.state().subscribe(function(s) {
+                                    var _s_pending;
+                                    var _s_pending_all;
+                                    var pending = (_s_pending_all = s === null || s === void 0 ? void 0 : (_s_pending = s.pending) === null || _s_pending === void 0 ? void 0 : _s_pending.all) !== null && _s_pending_all !== void 0 ? _s_pending_all : [];
+                                    var sig = JSON.stringify(pending.map(function(p) {
+                                        var _p_result;
+                                        var _p_result_status;
+                                        return {
+                                            id: function() {
+                                                try {
+                                                    var _p_tx_identifiers__slice, _p_tx_identifiers_;
+                                                    var _p_tx_identifiers__slice1;
+                                                    return (_p_tx_identifiers__slice1 = (_p_tx_identifiers_ = p.tx.identifiers()[0]) === null || _p_tx_identifiers_ === void 0 ? void 0 : (_p_tx_identifiers__slice = _p_tx_identifiers_.slice) === null || _p_tx_identifiers__slice === void 0 ? void 0 : _p_tx_identifiers__slice.call(_p_tx_identifiers_, 0, 12)) !== null && _p_tx_identifiers__slice1 !== void 0 ? _p_tx_identifiers__slice1 : '?';
+                                                } catch (e) {
+                                                    return '?';
+                                                }
+                                            }(),
+                                            resultStatus: (_p_result_status = (_p_result = p.result) === null || _p_result === void 0 ? void 0 : _p_result.status) !== null && _p_result_status !== void 0 ? _p_result_status : 'pending'
+                                        };
+                                    }));
+                                    if (sig === lastPendingSig) return;
+                                    lastPendingSig = sig;
+                                    if (pending.length === 0 && lastPendingCount === 0) return;
+                                    lastPendingCount = pending.length;
+                                    _this.logger.debug("[Midnight] pending-tx list (".concat(pending.length, "):"), pending.map(function(p) {
+                                        var _p_result;
+                                        // Guard every date/serialize call — `p.creationTime` may be an
+                                        // Effect DateTime (not a JS Date), `i.ttl` may be a bigint or
+                                        // something else that new Date() can't handle. Fall back to
+                                        // raw string representation if conversion fails.
+                                        var safeDate = function(v) {
+                                            try {
+                                                var d = new Date(v);
+                                                if (Number.isFinite(d.getTime())) return d.toISOString();
+                                                return String(v);
+                                            } catch (e) {
+                                                return String(v);
+                                            }
+                                        };
+                                        var intentTtls = [];
+                                        try {
+                                            var _p_tx_intents;
+                                            var _p_tx_intents_values_toArray;
+                                            intentTtls = ((_p_tx_intents_values_toArray = (_p_tx_intents = p.tx.intents) === null || _p_tx_intents === void 0 ? void 0 : _p_tx_intents.values().toArray()) !== null && _p_tx_intents_values_toArray !== void 0 ? _p_tx_intents_values_toArray : []).map(function(i) {
+                                                if ((i === null || i === void 0 ? void 0 : i.ttl) == null) return 'none';
+                                                // Midnight intent TTLs are typically seconds since epoch (may
+                                                // also arrive as bigint or Date). Multiply to ms only if the
+                                                // value is clearly in the seconds range (< 1e12).
+                                                var asNumber = _type_of(i.ttl) === 'bigint' ? Number(i.ttl) : i.ttl;
+                                                var ms = typeof asNumber === 'number' && asNumber < 1e12 ? asNumber * 1000 : asNumber;
+                                                return safeDate(ms);
+                                            });
+                                        } catch (e) {
+                                        /* ignore */ }
+                                        var idShort = '?';
+                                        try {
+                                            var _p_tx_identifiers__slice, _p_tx_identifiers_;
+                                            var _p_tx_identifiers__slice1;
+                                            idShort = (_p_tx_identifiers__slice1 = (_p_tx_identifiers_ = p.tx.identifiers()[0]) === null || _p_tx_identifiers_ === void 0 ? void 0 : (_p_tx_identifiers__slice = _p_tx_identifiers_.slice) === null || _p_tx_identifiers__slice === void 0 ? void 0 : _p_tx_identifiers__slice.call(_p_tx_identifiers_, 0, 16)) !== null && _p_tx_identifiers__slice1 !== void 0 ? _p_tx_identifiers__slice1 : '?';
+                                        } catch (e) {
+                                        /* ignore */ }
+                                        var _p_result_status;
+                                        return {
+                                            id: idShort,
+                                            creationTime: p.creationTime == null ? 'n/a' : safeDate(p.creationTime),
+                                            result: (_p_result_status = (_p_result = p.result) === null || _p_result === void 0 ? void 0 : _p_result.status) !== null && _p_result_status !== void 0 ? _p_result_status : 'pending',
+                                            intentTtls: intentTtls
+                                        };
+                                    }));
+                                });
+                                _this.cachedWallet = {
+                                    wallet: wallet,
+                                    ledger: ledger__namespace,
+                                    roleKeys: roleKeys,
+                                    accountAddress: accountAddress,
+                                    shieldedSecretKeys: shieldedSecretKeys,
+                                    dustSecretKey: dustSecretKey,
+                                    diagnosticSub: diagnosticSub
+                                };
+                                _this.logger.info("[Midnight] ".concat(label, ": wallet cached for future calls"));
+                                // Persist the freshly-synced state to IndexedDB so the next init can
+                                // resume. Routed through persistCachedWalletState so the same "clean
+                                // only" guard (Option A) applies — if this fresh sync somehow restored
+                                // dirty state (e.g., a lingering pending-tx entry from an earlier
+                                // session), we skip the write and keep IndexedDB at its last known-good.
+                                void _async_to_generator(function() {
+                                    var err;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                _state.trys.push([
+                                                    0,
+                                                    2,
+                                                    ,
+                                                    3
+                                                ]);
+                                                return [
+                                                    4,
+                                                    _this.persistCachedWalletState()
+                                                ];
+                                            case 1:
+                                                _state.sent();
+                                                return [
+                                                    3,
+                                                    3
+                                                ];
+                                            case 2:
+                                                err = _state.sent();
+                                                _this.logger.warn('[Midnight] Failed to persist wallet state:', err);
+                                                return [
+                                                    3,
+                                                    3
+                                                ];
+                                            case 3:
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                                return [
+                                    2,
+                                    {
+                                        wallet: wallet,
+                                        state: state1,
+                                        ledger: ledger__namespace,
+                                        roleKeys: roleKeys,
+                                        accountAddress: accountAddress,
+                                        shieldedSecretKeys: shieldedSecretKeys,
+                                        dustSecretKey: dustSecretKey
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getPrivateBalance",
+            value: function getPrivateBalance(param) {
+                var accountAddress = param.accountAddress, password = param.password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _state_unshielded, _state_shielded, _state_dust_balance, _state_dust, _ref, state, addr, unshieldedByToken, _state_unshielded_balances, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, tokenType, value, shieldedByToken, _state_shielded_balances, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value1, tokenType1, value1, _state_dust_balance1, result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('getPrivateBalance', {
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), state = _ref.state, addr = _ref.accountAddress;
+                                unshieldedByToken = {};
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = Object.entries((_state_unshielded_balances = (_state_unshielded = state.unshielded) === null || _state_unshielded === void 0 ? void 0 : _state_unshielded.balances) !== null && _state_unshielded_balances !== void 0 ? _state_unshielded_balances : {})[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        _step_value = _sliced_to_array(_step.value, 2), tokenType = _step_value[0], value = _step_value[1];
+                                        unshieldedByToken[tokenType] = value.toString();
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                                shieldedByToken = {};
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                try {
+                                    for(_iterator1 = Object.entries((_state_shielded_balances = (_state_shielded = state.shielded) === null || _state_shielded === void 0 ? void 0 : _state_shielded.balances) !== null && _state_shielded_balances !== void 0 ? _state_shielded_balances : {})[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                        _step_value1 = _sliced_to_array(_step1.value, 2), tokenType1 = _step_value1[0], value1 = _step_value1[1];
+                                        shieldedByToken[tokenType1] = value1.toString();
+                                    }
+                                } catch (err) {
+                                    _didIteratorError1 = true;
+                                    _iteratorError1 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                            _iterator1.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError1) {
+                                            throw _iteratorError1;
+                                        }
+                                    }
+                                }
+                                result = {
+                                    unshielded: unshieldedByToken,
+                                    shielded: shieldedByToken,
+                                    dust: ((_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).toString(),
+                                    address: addr
+                                };
+                                // Fire-and-forget snapshot so the next init resumes from here instead
+                                // of cold-syncing from genesis.
+                                void _this.persistCachedWalletState();
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "registerDust",
+            value: function registerDust(param) {
+                var accountAddress = param.accountAddress, password = param.password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _state_dust_balance, _state_dust, _state_unshielded, _state_dust_balance1, _state_dust1, _ref, wallet, state, ledger, roleKeys, _state_dust_balance2, existingDust, _state_unshielded_availableCoins, allUtxos, nightUtxos, _state_dust_balance3, _state_dust2, _state_dust_balance4, dustBalance, verifyingKey, recipe, finalized, submitId, submitIdStr, _state_dust_balance5;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('registerDust', {
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), wallet = _ref.wallet, state = _ref.state, ledger = _ref.ledger, roleKeys = _ref.roleKeys;
+                                existingDust = (_state_dust_balance2 = (_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_balance2 !== void 0 ? _state_dust_balance2 : 0n;
+                                if (existingDust > 0n) {
+                                    return [
+                                        2,
+                                        {
+                                            dustBalance: existingDust.toString(),
+                                            status: 'already_has_dust',
+                                            message: "Wallet already has ".concat(existingDust.toString(), " dust. No action needed."),
+                                            registeredCount: 0
+                                        }
+                                    ];
+                                }
+                                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 : [];
+                                nightUtxos = allUtxos.filter(function(coin) {
+                                    var _coin_meta;
+                                    return ((_coin_meta = coin.meta) === null || _coin_meta === void 0 ? void 0 : _coin_meta.registeredForDustGeneration) !== true;
+                                });
+                                _this.logger.info('[Midnight] registerDust: UTXOs total:', allUtxos.length, 'unregistered:', nightUtxos.length);
+                                if (nightUtxos.length === 0 && allUtxos.length > 0) {
+                                    dustBalance = ((_state_dust_balance4 = (_state_dust2 = state.dust) === null || _state_dust2 === void 0 ? void 0 : (_state_dust_balance3 = _state_dust2.balance) === null || _state_dust_balance3 === void 0 ? void 0 : _state_dust_balance3.call(_state_dust2, new Date())) !== null && _state_dust_balance4 !== void 0 ? _state_dust_balance4 : 0n).toString();
+                                    return [
+                                        2,
+                                        {
+                                            dustBalance: dustBalance,
+                                            status: 'already_registered',
+                                            message: "All ".concat(allUtxos.length, " NIGHT UTXO(s) are already registered for dust generation. ") + "Current dust balance is ".concat(dustBalance, ". Dust generation runs continuously on-chain — ") + "poll getPrivateBalance periodically to see it accumulate. If it stays at 0 for a long " + "time past the grace period (3h on preview), the NIGHT UTXO may be generating too " + "slowly to show up — fund the wallet with more NIGHT to increase the rate.",
+                                            registeredCount: 0
+                                        }
+                                    ];
+                                }
+                                if (nightUtxos.length === 0) {
+                                    return [
+                                        2,
+                                        {
+                                            dustBalance: '0',
+                                            status: 'no_utxos',
+                                            message: 'No NIGHT UTXOs in wallet. Fund the wallet with NIGHT from the preview faucet before registering for dust.',
+                                            registeredCount: 0
+                                        }
+                                    ];
+                                }
+                                _this.logger.debug("[Midnight] registerDust: registering ".concat(nightUtxos.length, " NIGHT UTXO(s) for dust generation..."));
+                                verifyingKey = ledger.signatureVerifyingKey(roleKeys.unshielded);
+                                _this.logger.debug('[Midnight] registerDust: building registration recipe...');
+                                return [
+                                    4,
+                                    wallet.registerNightUtxosForDustGeneration(nightUtxos, verifyingKey, function(payload) {
+                                        return ledger.signData(roleKeys.unshielded, payload);
+                                    })
+                                ];
+                            case 2:
+                                recipe = _state.sent();
+                                _this.logger.debug('[Midnight] registerDust: proving + finalizing (proof server)...');
+                                return [
+                                    4,
+                                    wallet.finalizeRecipe(recipe)
+                                ];
+                            case 3:
+                                finalized = _state.sent();
+                                _this.logger.debug('[Midnight] registerDust: broadcasting registration tx...');
+                                return [
+                                    4,
+                                    wallet.submitTransaction(finalized)
+                                ];
+                            case 4:
+                                submitId = _state.sent();
+                                submitIdStr = DynamicMidnightWalletClient.toTxHashString(submitId);
+                                _this.logger.debug("[Midnight] registerDust: broadcast, txId=".concat(submitIdStr));
+                                // Do NOT block here waiting for dust. Dust generation is a continuous
+                                // on-chain process — it can take minutes to hours depending on NIGHT
+                                // value, grace period, and decay rate. Return immediately so the UI can
+                                // show "registration submitted" and the caller polls getPrivateBalance
+                                // to observe dust when it eventually appears.
+                                void _this.persistCachedWalletState();
+                                return [
+                                    2,
+                                    {
+                                        dustBalance: ((_state_dust_balance5 = (_state_dust1 = state.dust) === null || _state_dust1 === void 0 ? void 0 : (_state_dust_balance1 = _state_dust1.balance) === null || _state_dust_balance1 === void 0 ? void 0 : _state_dust_balance1.call(_state_dust1, new Date())) !== null && _state_dust_balance5 !== void 0 ? _state_dust_balance5 : 0n).toString(),
+                                        txId: submitIdStr,
+                                        status: 'registered',
+                                        message: "Registered ".concat(nightUtxos.length, " NIGHT UTXO(s) for dust generation (txId ").concat(submitIdStr.slice(0, 16), "…). ") + "Dust will accumulate continuously on-chain. Poll getPrivateBalance to see it arrive " + "(usually a few minutes after the registration tx confirms, depending on network parameters).",
+                                        registeredCount: nightUtxos.length
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "createTransferTransaction",
+            value: /**
+   * Build an unsigned Midnight transfer (unshielded, shielded, or mixed).
+   * No MPC, no proof server, no broadcast — pair with signTransaction and
+   * submitTransaction.
+   */ function createTransferTransaction(param) {
+                var accountAddress = param.accountAddress, transfers = param.transfers, ttlMinutes = param.ttlMinutes, password = param.password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _state_dust_balance, _state_dust, _ref, wallet, state, shieldedSecretKeys, dustSecretKey, _state_dust_balance1, dustBalance, nativeToken, requiredByKey, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, t, _t_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, ttlMs, recipe;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!transfers || transfers.length === 0) {
+                                    throw new Error('At least one transfer is required');
+                                }
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('createTransferTransaction', {
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), wallet = _ref.wallet, state = _ref.state, shieldedSecretKeys = _ref.shieldedSecretKeys, dustSecretKey = _ref.dustSecretKey;
+                                // Dust fee is required for every Midnight transaction regardless of the transfer type.
+                                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, new Date())) !== null && _state_dust_balance1 !== void 0 ? _state_dust_balance1 : 0n;
+                                if (dustBalance === 0n) {
+                                    throw new Error('No dust balance — register dust first');
+                                }
+                                nativeToken = ledger__namespace.nativeToken().raw;
+                                // Aggregate per-(side, token) amounts so a single tx spending the same token
+                                // across multiple outputs gets checked against one combined total. The Map
+                                // value keeps the parsed components so we don't have to round-trip the key
+                                // through string-splitting — a token identifier containing `:` (Midnight
+                                // contract tokens can) would truncate if we split on ':' to recover it.
+                                requiredByKey = new Map();
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = transfers[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        t = _step.value;
+                                        ;
+                                        token = (_t_tokenType = t.tokenType) !== null && _t_tokenType !== void 0 ? _t_tokenType : nativeToken;
+                                        // NUL-separated dedup key. The NUL byte cannot appear in a JS string
+                                        // literal produced by any Midnight address/token encoder, so collisions
+                                        // between (side, token) pairs are impossible regardless of token shape.
+                                        key = "".concat(t.type, "\0").concat(token);
+                                        existing = requiredByKey.get(key);
+                                        ;
+                                        requiredByKey.set(key, {
+                                            side: t.type,
+                                            token: token,
+                                            required: ((_existing_required = existing === null || existing === void 0 ? void 0 : existing.required) !== null && _existing_required !== void 0 ? _existing_required : 0n) + BigInt(t.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(t) {
+                                    var _t_tokenType;
+                                    var token = (_t_tokenType = t.tokenType) !== null && _t_tokenType !== void 0 ? _t_tokenType : nativeToken;
+                                    var receiverAddress;
+                                    try {
+                                        var parsed = walletSdkAddressFormat.MidnightBech32m.parse(t.recipientAddress);
+                                        receiverAddress = t.type === 'unshielded' ? parsed.decode(walletSdkAddressFormat.UnshieldedAddress, 'preview') : parsed.decode(walletSdkAddressFormat.ShieldedAddress, 'preview');
+                                    } catch (err) {
+                                        throw new Error("Invalid ".concat(t.type, " recipient address ").concat(t.recipientAddress, ": ").concat(err.message));
+                                    }
+                                    _this.logger.info("[Midnight] createTransferTransaction: ".concat(t.type, " ").concat(t.amount, " of token ").concat(token.slice(0, 8), "… → ").concat(t.recipientAddress.slice(0, 20), "…"));
+                                    return {
+                                        type: t.type,
+                                        outputs: [
+                                            {
+                                                amount: BigInt(t.amount),
+                                                receiverAddress: receiverAddress,
+                                                type: token
+                                            }
+                                        ]
+                                    };
+                                });
+                                // TTL defaults to 5 min. If the caller doesn't submit within this window,
+                                // the SDK's PendingTransactions.allFailed stream picks up the expired tx
+                                // and auto-reverts the reserved UTXOs back to available. Short enough
+                                // that abandoned drafts recover quickly; long enough for a normal
+                                // craft → sign (ZK prove) → submit path to complete comfortably.
+                                // Callers can override via ttlMinutes for relayer/batched-submit flows.
+                                ttlMs = (ttlMinutes !== null && ttlMinutes !== void 0 ? ttlMinutes : 5) * 60 * 1000;
+                                return [
+                                    4,
+                                    wallet.transferTransaction(sdkTransfers, {
+                                        shieldedSecretKeys: shieldedSecretKeys,
+                                        dustSecretKey: dustSecretKey
+                                    }, {
+                                        ttl: new Date(Date.now() + ttlMs)
+                                    })
+                                ];
+                            case 2:
+                                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')
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "submitTransaction",
+            value: /**
+   * Broadcast a finalized Midnight transaction. Pure RPC — no MPC, no proof
+   * server; reuses the cached wallet's node connection. Optionally blocks
+   * until the unshielded balance for tokenType stabilizes.
+   */ function submitTransaction(param) {
+                var accountAddress = param.accountAddress, transaction = param.transaction, _param_waitForBalance = param.waitForBalance, waitForBalance = _param_waitForBalance === void 0 ? false : _param_waitForBalance, tokenType = param.tokenType, balanceBefore = param.balanceBefore, password = param.password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _updatedState_unshielded_balances, _updatedState_unshielded, wallet, txBytes, finalized, txIdentifier, txHash, balanceBeforeBig, updatedState, _updatedState_unshielded_balances_tokenType, balanceAfter;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('submitTransaction', {
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                wallet = _state.sent().wallet;
+                                txBytes = Buffer.from(transaction, 'base64');
+                                finalized = ledger__namespace.Transaction.deserialize('signature', 'proof', 'binding', new Uint8Array(txBytes));
+                                _this.logger.info('[Midnight] submitTransaction: broadcasting...');
+                                return [
+                                    4,
+                                    wallet.submitTransaction(finalized)
+                                ];
+                            case 2:
+                                txIdentifier = _state.sent();
+                                txHash = DynamicMidnightWalletClient.toTxHashString(txIdentifier);
+                                _this.logger.info('[Midnight] submitTransaction: broadcast, txHash=', txHash);
+                                if (!waitForBalance) {
+                                    void _this.persistCachedWalletState();
+                                    return [
+                                        2,
+                                        {
+                                            txHash: txHash
+                                        }
+                                    ];
+                                }
+                                if (!tokenType || balanceBefore === undefined) {
+                                    throw new Error('tokenType and balanceBefore are required when waitForBalance is true');
+                                }
+                                balanceBeforeBig = BigInt(balanceBefore);
+                                _this.logger.info('[Midnight] submitTransaction: waiting for balance to stabilize...');
+                                return [
+                                    4,
+                                    new Promise(function(resolve, reject) {
+                                        // Same TDZ-safe pattern used at every other subscribe site in the
+                                        // file: `let sub` + optional chaining so if `.subscribe()` throws
+                                        // synchronously (before `sub` is initialized) the hardTimeout and
+                                        // stable-timer closures don't hit a TDZ ReferenceError.
+                                        // eslint-disable-next-line prefer-const
+                                        var sub;
+                                        var hardTimeout = setTimeout(function() {
+                                            sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                            reject(new Error('Balance update timeout'));
+                                        }, 120000);
+                                        var lastState = null;
+                                        var lastValue = null;
+                                        var stableTimer = null;
+                                        sub = wallet.state().subscribe(function(s) {
+                                            var _s_unshielded_balances, _s_unshielded;
+                                            var _s_unshielded_balances_tokenType;
+                                            var current = (_s_unshielded_balances_tokenType = (_s_unshielded = s.unshielded) === null || _s_unshielded === void 0 ? void 0 : (_s_unshielded_balances = _s_unshielded.balances) === null || _s_unshielded_balances === void 0 ? void 0 : _s_unshielded_balances[tokenType]) !== null && _s_unshielded_balances_tokenType !== void 0 ? _s_unshielded_balances_tokenType : 0n;
+                                            if (current === balanceBeforeBig) return;
+                                            lastState = s;
+                                            if (lastValue !== current) {
+                                                lastValue = current;
+                                                if (stableTimer) clearTimeout(stableTimer);
+                                                stableTimer = setTimeout(function() {
+                                                    clearTimeout(hardTimeout);
+                                                    sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                                    resolve(lastState);
+                                                }, 3000);
+                                            }
+                                        });
+                                    })
+                                ];
+                            case 3:
+                                updatedState = _state.sent();
+                                balanceAfter = (_updatedState_unshielded_balances_tokenType = (_updatedState_unshielded = updatedState.unshielded) === null || _updatedState_unshielded === void 0 ? void 0 : (_updatedState_unshielded_balances = _updatedState_unshielded.balances) === null || _updatedState_unshielded_balances === void 0 ? void 0 : _updatedState_unshielded_balances[tokenType]) !== null && _updatedState_unshielded_balances_tokenType !== void 0 ? _updatedState_unshielded_balances_tokenType : 0n;
+                                void _this.persistCachedWalletState();
+                                return [
+                                    2,
+                                    {
+                                        txHash: txHash,
+                                        balanceAfter: balanceAfter.toString()
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "revertTransaction",
+            value: /**
+   * Release UTXOs reserved by drafted or signed-but-never-submitted Midnight
+   * transactions. Three mutually exclusive modes, resolved by priority below.
+   *
+   * Priority order:
+   *   1. `resetCache` — nuclear: stops cached wallet, deletes the account's
+   *      persisted state from IndexedDB, forces next operation to cold-sync.
+   *      Use this when reference to specific pending txs is lost, or state
+   *      got into a stuck configuration that can't be reverted otherwise.
+   *      This is Midnight's documented workaround for "pending coins not
+   *      cleared after failed shielded transaction".
+   *   2. `transaction` — revert one specific tx by its base64 serialization.
+   *      Accepts either UnprovenTransaction (step 1 output) or
+   *      FinalizedTransaction (step 2 output).
+   *   3. `all` — iterate `state.pending.all` and revert each. Covers every
+   *      finalized tx the SDK knows about. Does NOT cover Step-1-only drafts
+   *      (those are never registered with the pending-tx service — by design
+   *      per Midnight, because unproven transactions hold secret-key material).
+   *
+   * Exactly one of the three must be truthy; otherwise this throws.
+   */ function revertTransaction(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        if (params.resetCache) {
+                            return [
+                                2,
+                                _this.revertModeResetCache(params.accountAddress)
+                            ];
+                        }
+                        if (params.transaction) {
+                            return [
+                                2,
+                                _this.revertModeSingleTransaction(params)
+                            ];
+                        }
+                        if (params.all) {
+                            return [
+                                2,
+                                _this.revertModeAllPending(params)
+                            ];
+                        }
+                        throw new Error('revertTransaction requires one of: transaction, all, resetCache');
+                    });
+                })();
+            }
+        },
+        {
+            key: "revertModeResetCache",
+            value: function revertModeResetCache(accountAddress) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _this_cachedWallet, _this_cachedWallet_diagnosticSub, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this.logger.info('[Midnight] revertTransaction[resetCache]: stopping cached wallet and clearing persisted state...');
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    8,
+                                    ,
+                                    9
+                                ]);
+                                if (!(((_this_cachedWallet = _this.cachedWallet) === null || _this_cachedWallet === void 0 ? void 0 : _this_cachedWallet.accountAddress) === accountAddress)) return [
+                                    3,
+                                    6
+                                ];
+                                try {
+                                    ;
+                                    (_this_cachedWallet_diagnosticSub = _this.cachedWallet.diagnosticSub) === null || _this_cachedWallet_diagnosticSub === void 0 ? void 0 : _this_cachedWallet_diagnosticSub.unsubscribe();
+                                } catch (e) {
+                                /* ignore */ }
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    _this.cachedWallet.wallet.stop()
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                _this.cachedWallet = null;
+                                _state.label = 6;
+                            case 6:
+                                return [
+                                    4,
+                                    deleteWalletState(accountAddress)
+                                ];
+                            case 7:
+                                _state.sent();
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 8:
+                                err = _state.sent();
+                                throw new Error("resetCache failed: ".concat(err.message));
+                            case 9:
+                                _this.logger.info('[Midnight] revertTransaction[resetCache]: cache cleared');
+                                return [
+                                    2,
+                                    {
+                                        reverted: true,
+                                        count: 0,
+                                        cacheCleared: true,
+                                        message: 'Wallet cache reset. The cached wallet instance was stopped, the persisted IndexedDB entry for this account was deleted, and the next operation will cold-sync from chain.'
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "revertModeSingleTransaction",
+            value: function revertModeSingleTransaction(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var wallet, txBytes, tx;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('revertTransaction', {
+                                        accountAddress: params.accountAddress,
+                                        password: params.password,
+                                        signedSessionId: params.signedSessionId,
+                                        mfaToken: params.mfaToken,
+                                        elevatedAccessToken: params.elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                wallet = _state.sent().wallet;
+                                txBytes = new Uint8Array(Buffer.from(params.transaction, 'base64'));
+                                tx = _this.deserializeAnyMidnightTx(txBytes);
+                                _this.logger.info('[Midnight] revertTransaction[single]: reverting specific tx...');
+                                return [
+                                    4,
+                                    wallet.revert(tx)
+                                ];
+                            case 2:
+                                _state.sent();
+                                void _this.persistCachedWalletState();
+                                return [
+                                    2,
+                                    {
+                                        reverted: true,
+                                        count: 1,
+                                        cacheCleared: false,
+                                        message: 'Transaction reverted. Reserved UTXOs have been returned to the available set.'
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "revertModeAllPending",
+            value: function revertModeAllPending(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _snapshot_pending, wallet, snapshot, _snapshot_pending_all, pending, reverted, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, err1, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('revertTransaction', {
+                                        accountAddress: params.accountAddress,
+                                        password: params.password,
+                                        signedSessionId: params.signedSessionId,
+                                        mfaToken: params.mfaToken,
+                                        elevatedAccessToken: params.elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                wallet = _state.sent().wallet;
+                                _this.logger.info('[Midnight] revertTransaction[all]: reading pending-tx list...');
+                                return [
+                                    4,
+                                    _this.snapshotWalletState(wallet)
+                                ];
+                            case 2:
+                                snapshot = _state.sent();
+                                pending = (_snapshot_pending_all = snapshot === null || snapshot === void 0 ? void 0 : (_snapshot_pending = snapshot.pending) === null || _snapshot_pending === void 0 ? void 0 : _snapshot_pending.all) !== null && _snapshot_pending_all !== void 0 ? _snapshot_pending_all : [];
+                                _this.logger.info("[Midnight] revertTransaction[all]: reverting ".concat(pending.length, " pending tx(s)..."));
+                                reverted = 0;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 3;
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    10,
+                                    11,
+                                    12
+                                ]);
+                                _iterator = pending[Symbol.iterator]();
+                                _state.label = 4;
+                            case 4:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    9
+                                ];
+                                item = _step.value;
+                                _state.label = 5;
+                            case 5:
+                                _state.trys.push([
+                                    5,
+                                    7,
+                                    ,
+                                    8
+                                ]);
+                                return [
+                                    4,
+                                    wallet.revert(item.tx)
+                                ];
+                            case 6:
+                                _state.sent();
+                                reverted += 1;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                err1 = _state.sent();
+                                _this.logger.warn('[Midnight] revertTransaction[all]: revert failed for one tx, continuing:', err1);
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 8:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 9:
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 10:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 11:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 12:
+                                void _this.persistCachedWalletState();
+                                return [
+                                    2,
+                                    {
+                                        reverted: true,
+                                        count: reverted,
+                                        cacheCleared: false,
+                                        message: reverted > 0 ? "Reverted ".concat(reverted, " pending transaction(s). Step-1-only drafts are not covered — use resetCache if UTXOs are still stuck.") : 'No pending transactions to revert. If UTXOs are still stuck, the tx was likely an unfinalized draft — use resetCache to clear local state.'
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "deserializeAnyMidnightTx",
+            value: // Try unproven first (more common abandonment point), fall back to finalized.
+            function deserializeAnyMidnightTx(txBytes) {
+                try {
+                    return ledger__namespace.Transaction.deserialize('signature', 'pre-proof', 'pre-binding', txBytes);
+                } catch (e) {
+                    try {
+                        return ledger__namespace.Transaction.deserialize('signature', 'proof', 'binding', txBytes);
+                    } catch (err) {
+                        throw new Error("Could not deserialize transaction as either UnprovenTransaction or FinalizedTransaction: ".concat(err.message));
+                    }
+                }
+            }
+        },
+        {
+            key: "snapshotWalletState",
+            value: // Take a single snapshot of wallet state via the observable. Same
+            // subscribe-once pattern we use elsewhere — no rxjs dependency needed.
+            function snapshotWalletState(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 tid = setTimeout(function() {
+                                    sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                    reject(new Error('Timed out waiting for wallet state snapshot'));
+                                }, 10000);
+                                sub = wallet.state().subscribe(function(s) {
+                                    clearTimeout(tid);
+                                    queueMicrotask(function() {
+                                        return sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+                                    });
+                                    resolve(s);
+                                });
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "mpcSignIntents",
+            value: /**
+   * Sign all unshielded intents in a transaction via MPC.
+   * Mutates tx.intents in place with signatures attached.
+   * No-op for pure shielded transactions (0 unshielded segments).
+   *
+   * Each per-segment sign call carries the full unsigned tx in context so
+   * wallet-service policy sees the whole transaction once per signature
+   * (same pattern as BTC's PSBT in per-input context).
+   */ function mpcSignIntents(tx, options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _tx_intents, accountAddress, password, signedSessionId, mfaToken, elevatedAccessToken, fullTxBase64, networkId, baseContext, _options_proofMarker, proofMarker, _tx_intents_keys_toArray, segments, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                accountAddress = options.accountAddress, password = options.password, signedSessionId = options.signedSessionId, mfaToken = options.mfaToken, elevatedAccessToken = options.elevatedAccessToken, fullTxBase64 = options.fullTxBase64, networkId = options.networkId, baseContext = options.baseContext, _options_proofMarker = options.proofMarker, proofMarker = _options_proofMarker === void 0 ? 'pre-proof' : _options_proofMarker;
+                                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, " segment(s)..."));
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _loop = function() {
+                                    var segment, intent, cloned, sigData, hashBuffer, hash, signature, sigBytes, ledgerSig, sigs, sigs1;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                segment = _step.value;
+                                                intent = tx.intents.get(segment);
+                                                if (!intent) return [
+                                                    2,
+                                                    "continue"
+                                                ];
+                                                cloned = ledger__namespace.Intent.deserialize('signature', proofMarker, 'pre-binding', intent.serialize());
+                                                sigData = cloned.signatureData(segment);
+                                                return [
+                                                    4,
+                                                    crypto.subtle.digest('SHA-256', sigData)
+                                                ];
+                                            case 1:
+                                                hashBuffer = _state.sent();
+                                                hash = Array.from(new Uint8Array(hashBuffer)).map(function(b) {
+                                                    return b.toString(16).padStart(2, '0');
+                                                }).join('');
+                                                return [
+                                                    4,
+                                                    _this.sign({
+                                                        message: hash,
+                                                        accountAddress: accountAddress,
+                                                        chainName: _this.chainName,
+                                                        password: password,
+                                                        signedSessionId: signedSessionId,
+                                                        mfaToken: mfaToken,
+                                                        elevatedAccessToken: elevatedAccessToken,
+                                                        context: _object_spread_props(_object_spread({}, baseContext), {
+                                                            midnightTransaction: {
+                                                                serializedTransaction: fullTxBase64,
+                                                                networkId: networkId
+                                                            }
+                                                        })
+                                                    })
+                                                ];
+                                            case 2:
+                                                signature = _state.sent();
+                                                sigBytes = _instanceof(signature, Uint8Array) ? signature : Buffer.from(signature, 'base64');
+                                                ledgerSig = Buffer.from(sigBytes).toString('hex');
+                                                if (cloned.fallibleUnshieldedOffer) {
+                                                    sigs = cloned.fallibleUnshieldedOffer.inputs.map(function(_, i) {
+                                                        var _cloned_fallibleUnshieldedOffer_signatures_at;
+                                                        return (_cloned_fallibleUnshieldedOffer_signatures_at = cloned.fallibleUnshieldedOffer.signatures.at(i)) !== null && _cloned_fallibleUnshieldedOffer_signatures_at !== void 0 ? _cloned_fallibleUnshieldedOffer_signatures_at : ledgerSig;
+                                                    });
+                                                    cloned.fallibleUnshieldedOffer = cloned.fallibleUnshieldedOffer.addSignatures(sigs);
+                                                }
+                                                if (cloned.guaranteedUnshieldedOffer) {
+                                                    sigs1 = cloned.guaranteedUnshieldedOffer.inputs.map(function(_, i) {
+                                                        var _cloned_guaranteedUnshieldedOffer_signatures_at;
+                                                        return (_cloned_guaranteedUnshieldedOffer_signatures_at = cloned.guaranteedUnshieldedOffer.signatures.at(i)) !== null && _cloned_guaranteedUnshieldedOffer_signatures_at !== void 0 ? _cloned_guaranteedUnshieldedOffer_signatures_at : ledgerSig;
+                                                    });
+                                                    cloned.guaranteedUnshieldedOffer = cloned.guaranteedUnshieldedOffer.addSignatures(sigs1);
+                                                }
+                                                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: "getWalletProvider",
+            value: /**
+   * Returns a Midnight.js-compatible WalletProvider for use with
+   * midnight-js-contracts. Signing goes through MPC — no private key exposed.
+   */ function getWalletProvider(param) {
+                var accountAddress = param.accountAddress, password = param.password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _ref, wallet, state, shieldedSecretKeys, dustSecretKey, walletProvider;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.initMidnightWallet('walletProvider', {
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), wallet = _ref.wallet, state = _ref.state, shieldedSecretKeys = _ref.shieldedSecretKeys, dustSecretKey = _ref.dustSecretKey;
+                                walletProvider = {
+                                    getCoinPublicKey: function() {
+                                        return state.shielded.coinPublicKey.toHexString();
+                                    },
+                                    getEncryptionPublicKey: function() {
+                                        return state.shielded.encryptionPublicKey.toHexString();
+                                    },
+                                    balanceTx: /*#__PURE__*/ function() {
+                                        var _ref = _async_to_generator(function(tx, ttl) {
+                                            var recipe, baseTxB64, balancingTxB64;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        _this.logger.info('[Midnight] walletProvider.balanceTx: balancing transaction...');
+                                                        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 proven base tx uses the 'proof' marker. networkId 0 matches
+                                                        // the 'preview' facade network this provider is configured for.
+                                                        baseTxB64 = Buffer.from(recipe.baseTransaction.serialize()).toString('base64');
+                                                        return [
+                                                            4,
+                                                            _this.mpcSignIntents(recipe.baseTransaction, {
+                                                                accountAddress: accountAddress,
+                                                                password: password,
+                                                                signedSessionId: signedSessionId,
+                                                                mfaToken: mfaToken,
+                                                                elevatedAccessToken: elevatedAccessToken,
+                                                                fullTxBase64: baseTxB64,
+                                                                networkId: 0,
+                                                                proofMarker: 'proof'
+                                                            })
+                                                        ];
+                                                    case 2:
+                                                        _state.sent();
+                                                        if (!recipe.balancingTransaction) return [
+                                                            3,
+                                                            4
+                                                        ];
+                                                        balancingTxB64 = Buffer.from(recipe.balancingTransaction.serialize()).toString('base64');
+                                                        return [
+                                                            4,
+                                                            _this.mpcSignIntents(recipe.balancingTransaction, {
+                                                                accountAddress: accountAddress,
+                                                                password: password,
+                                                                signedSessionId: signedSessionId,
+                                                                mfaToken: mfaToken,
+                                                                elevatedAccessToken: elevatedAccessToken,
+                                                                fullTxBase64: balancingTxB64,
+                                                                networkId: 0,
+                                                                proofMarker: 'pre-proof'
+                                                            })
+                                                        ];
+                                                    case 3:
+                                                        _state.sent();
+                                                        _state.label = 4;
+                                                    case 4:
+                                                        _this.logger.info('[Midnight] walletProvider.balanceTx: finalizing...');
+                                                        return [
+                                                            2,
+                                                            wallet.finalizeRecipe(recipe)
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(tx, ttl) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }(),
+                                    submitTx: function(tx) {
+                                        _this.logger.info('[Midnight] walletProvider.submitTx: submitting...');
+                                        return wallet.submitTransaction(tx);
+                                    }
+                                };
+                                return [
+                                    2,
+                                    {
+                                        walletProvider: walletProvider,
+                                        wallet: wallet,
+                                        state: state,
+                                        shieldedSecretKeys: shieldedSecretKeys,
+                                        dustSecretKey: dustSecretKey
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            key: "toTxHashString",
+            value: /**
+   * Coerce the value returned by `wallet.submitTransaction(...)` to a string.
+   * Midnight's facade returns either a string txId, or a TransactionIdentifier
+   * object with a `.toHex()` method. We normalize so callers always see a
+   * string, and fall back to `String(...)` if neither shape matches.
+   */ function toTxHashString(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);
+            }
+        }
+    ]);
+    return DynamicMidnightWalletClient;
+}(browser.DynamicWalletClient);
+
+/**
+ * Address prefixes for Bech32m encoding (BIP-0350)
+ */ var ADDRESS_PREFIXES = {
+    mainnet: 'mn_addr',
+    preview: 'mn_addr_preview',
+    preprod: 'mn_addr_preprod',
+    undeployed: 'mn_addr_undeployed'
+};
+/**
+ * Derives a Midnight unshielded address from a 32-byte address hash.
+ * NOTE: Midnight addresses are Poseidon hashes of the public key, not the raw key.
+ * The address hash should be computed server-side using ledger.addressFromKey().
+ * If publicKeyHex is passed, it's assumed to already be the address hash.
+ *
+ * @param publicKeyHex - The 32-byte address hash (from addressFromKey) as hex string
+ * @param network - The network. Defaults to preview
+ * @returns Bech32m encoded address (e.g., mn_addr_preview1...)
+ */ var deriveMidnightAddress = function(param) {
+    var publicKeyHex = param.publicKeyHex, _param_network = param.network, network = _param_network === void 0 ? 'preview' : _param_network;
+    var bytes = Buffer.from(publicKeyHex, 'hex');
+    if (bytes.length !== 32) {
+        throw new Error("Invalid key length: ".concat(bytes.length, ", expected 32"));
+    }
+    var prefix = ADDRESS_PREFIXES[network];
+    var words = bech32.bech32m.toWords(bytes);
+    return bech32.bech32m.encode(prefix, words);
+};
+// `'mn_addr'` is a strict prefix of every other value in ADDRESS_PREFIXES,
+// so naive `startsWith` checks hit `mainnet` for any Midnight address. Always
+// check longest prefix first (descending).
+Object.entries(ADDRESS_PREFIXES).slice().sort(function(a, b) {
+    return b[1].length - a[1].length;
+});
+
+exports.sdkApiCore = sdkApiCore__namespace;
+exports.DynamicMidnightWalletClient = DynamicMidnightWalletClient;
+exports.MIDNIGHT_NETWORK_IDS = MIDNIGHT_NETWORK_IDS;
+exports.deriveMidnightAddress = deriveMidnightAddress;