@dynamic-labs-wallet/aleo 0.0.0 → 0.0.331

package/index.cjs.js

@@ -0,0 +1,3339 @@
+'use strict';
+
+var browser = require('@dynamic-labs-wallet/browser');
+var AleoSdkMainnet = require('@provablehq/sdk/mainnet.js');
+var AleoSdkTestnet = require('@provablehq/sdk/testnet.js');
+
+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 AleoSdkMainnet__namespace = /*#__PURE__*/_interopNamespaceDefault(AleoSdkMainnet);
+var AleoSdkTestnet__namespace = /*#__PURE__*/_interopNamespaceDefault(AleoSdkTestnet);
+
+var ERROR_KEYGEN_FAILED = 'Error with Aleo keygen';
+var ERROR_CREATE_WALLET_ACCOUNT = 'Error creating Aleo wallet account';
+var ERROR_ACCOUNT_ADDRESS_REQUIRED = 'Account address is required';
+var ERROR_EXPORT_PRIVATE_KEY = 'Error exporting Aleo private key';
+var ERROR_IMPORT_PRIVATE_KEY_NOT_SUPPORTED = 'Aleo importPrivateKey is not supported yet';
+var ERROR_SIGN_MESSAGE_NOT_SUPPORTED = 'Aleo signMessage is not supported yet — pending arbitrary-bytes EdBls12377 signing';
+var ERROR_SIGN_TRANSACTION_NOT_SUPPORTED = 'Aleo signTransaction is not supported yet — coming in Phase 2';
+var ALEO_NETWORKS = {
+    MAINNET: 'mainnet',
+    TESTNET: 'testnet'
+};
+/**
+ * Default Provable Delegated Proving Service endpoint.
+ * Used by `submitProvingRequest` — Provable computes the ZK proof on their
+ * accelerator hardware and (optionally) broadcasts. No API key required for
+ * testnet during Phase 2.
+ */ var DEFAULT_PROVABLE_PROVER_URI = 'https://accelerate.provable.com';
+
+/**
+ * IndexedDB-backed persistence for Aleo per-wallet record-scanner state.
+ *
+ * We cache the scanner's UUID, the owned-records list, and the spent-record
+ * nonces per accountAddress so subsequent queries resume from the last known
+ * state instead of re-registering with Provable's scanner on every page load.
+ *
+ * Storage shape (object store "state", keyed by `${accountAddress}:${network}`):
+ *   { accountAddress, network, scannerUuid, records, spentNonces, lastScannedBlock,
+ *     sealanceProofs, updatedAt }
+ *
+ * The keyPath value is the composite `${accountAddress}:${network}` so testnet
+ * and mainnet entries for the same wallet don't collide. Pre-network-aware
+ * entries (raw `accountAddress` keys) are functionally orphaned by the new
+ * composite lookups and will simply be re-registered on first call. Acceptable
+ * one-time cost; avoids a DB schema migration / version bump.
+ *
+ * `records` is a JSON-stringified array of `OwnedRecord` — keeping it as a
+ * string lets us cache decrypted plaintexts without imposing a Provable SDK
+ * type dependency on this persistence module.
+ *
+ * Security: blobs are stored plaintext, matching Dynamic's existing policy
+ * for locally-cached key material. Protection comes from the iframe's origin
+ * isolation, not at-rest encryption. Cloned from Midnight's
+ * walletStateStorage.ts; a future refactor may extract a generic kv store.
+ */ function asyncGeneratorStep$3(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$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof$2(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$3(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-aleo-wallet-state';
+var DB_VERSION = 1;
+var STORE_NAME = 'state';
+/** Composes the IndexedDB key from a wallet address + network. Exported so
+ *  callers can build the same string when they need to look up a record
+ *  outside the standard `getWalletState` path. */ var buildStorageKey = function(accountAddress, network) {
+    return "".concat(accountAddress, ":").concat(network);
+};
+// 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$2(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).
+    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$3(function(mode, fn) {
+        var db;
+        return _ts_generator$3(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, network) {
+    return _getWalletState.apply(this, arguments);
+}
+function _getWalletState() {
+    _getWalletState = _async_to_generator$3(function(accountAddress, network) {
+        var key, result;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    key = buildStorageKey(accountAddress, network);
+                    return [
+                        4,
+                        runTransaction('readonly', function(store) {
+                            return store.get(key);
+                        })
+                    ];
+                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, network, state) {
+    return _putWalletState.apply(this, arguments);
+}
+function _putWalletState() {
+    _putWalletState = _async_to_generator$3(function(accountAddress, network, state) {
+        var record;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    record = {
+                        accountAddress: buildStorageKey(accountAddress, network),
+                        walletAddress: accountAddress,
+                        network: network,
+                        scannerUuid: state.scannerUuid,
+                        records: state.records,
+                        spentNonces: state.spentNonces,
+                        lastScannedBlock: state.lastScannedBlock,
+                        sealanceProofs: state.sealanceProofs,
+                        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);
+}
+
+/**
+ * Iframe-side Feemaster surface used by `proveTransaction`.
+ *
+ * Earlier versions made `fetch()` calls to ANF directly with a hardcoded
+ * Bearer key shipped in the iframe bundle. As of Phase A1 the iframe goes
+ * through redcoast (which holds the ANF key server-side) — and by reusing
+ * the existing `DynamicApiClient` in `@dynamic-labs-wallet/core`, all the
+ * baseApiUrl / Authorization-header / retry plumbing is shared with the
+ * other waas redcoast endpoints (`exportAleoViewKey`, `signAleoRequest`,
+ * etc.).
+ *
+ * This file is now a thin wrapper that:
+ *   - holds the network the iframe is bound to
+ *   - keeps a 5-min in-memory policy cache (matches the previous behaviour)
+ *   - delegates HTTP work to `DynamicApiClient`
+ *
+ * Surface kept identical (`fetchPolicy`, `isCovered`, `requestFeeAuthorization`)
+ * so call sites in `proveTransaction` don't change.
+ */ function asyncGeneratorStep$2(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$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(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$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(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 _ts_generator$2(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 POLICY_TTL_MS = 5 * 60 * 1000;
+var FeemasterClient = /*#__PURE__*/ function() {
+    function FeemasterClient(args) {
+        _class_call_check$2(this, FeemasterClient);
+        _define_property$2(this, "apiClient", void 0);
+        _define_property$2(this, "network", void 0);
+        _define_property$2(this, "policyCache", null);
+        this.apiClient = args.apiClient;
+        this.network = args.network;
+    }
+    _create_class$2(FeemasterClient, [
+        {
+            key: "fetchPolicy",
+            value: /** Fetches the Feemaster policy for the configured network. Cached for
+   *  5 minutes; pass `force: true` after a quota-exhausted response. */ function fetchPolicy() {
+                var force = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+                var _this = this;
+                return _async_to_generator$2(function() {
+                    var policy;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!force && _this.policyCache && Date.now() - _this.policyCache.cachedAt < POLICY_TTL_MS) {
+                                    return [
+                                        2,
+                                        _this.policyCache.policy
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    _this.apiClient.getAleoFeemasterPolicy({
+                                        network: _this.network
+                                    })
+                                ];
+                            case 1:
+                                policy = _state.sent();
+                                _this.policyCache = {
+                                    policy: policy,
+                                    cachedAt: Date.now()
+                                };
+                                return [
+                                    2,
+                                    policy
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "isCovered",
+            value: /** Returns true when the configured network's policy permits sponsoring
+   *  `(programId, functionName)`. Never throws — returns false on any
+   *  policy fetch failure so callers can fall back to user-paid. */ function isCovered(programId, functionName) {
+                var _this = this;
+                return _async_to_generator$2(function() {
+                    var policy, entry;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                return [
+                                    4,
+                                    _this.apiClient.isAleoFeemasterCovered({
+                                        network: _this.network,
+                                        programId: programId,
+                                        functionName: functionName
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                return [
+                                    4,
+                                    _this.fetchPolicy()
+                                ];
+                            case 4:
+                                policy = _state.sent();
+                                if (!policy.allowed_programs) return [
+                                    2,
+                                    true
+                                ];
+                                entry = policy.allowed_programs.find(function(p) {
+                                    return p.program_id === programId;
+                                });
+                                if (!entry) return [
+                                    2,
+                                    false
+                                ];
+                                if (!entry.allowed_functions) return [
+                                    2,
+                                    true
+                                ];
+                                return [
+                                    2,
+                                    entry.allowed_functions.includes(functionName)
+                                ];
+                            case 5:
+                                _state.sent();
+                                return [
+                                    2,
+                                    false
+                                ];
+                            case 6:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "requestFeeAuthorization",
+            value: /** Forwards a user-signed Aleo Authorization to ANF (via redcoast) and
+   *  returns the corresponding `feeAuthorization` for bundling into a
+   *  ProvingRequest. Throws on quota / service errors so the caller falls
+   *  back to user-paid fees. */ function requestFeeAuthorization(params) {
+                var _this = this;
+                return _async_to_generator$2(function() {
+                    var feeAuthorization;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.apiClient.requestAleoFeeAuthorization({
+                                        network: _this.network,
+                                        authorization: params.authorizationString,
+                                        priorityFee: params.priorityFee
+                                    })
+                                ];
+                            case 1:
+                                feeAuthorization = _state.sent().feeAuthorization;
+                                return [
+                                    2,
+                                    {
+                                        feeAuthorizationString: feeAuthorization
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return FeemasterClient;
+}();
+
+/**
+ * Iframe-side RecordScanner that mirrors the Provable SDK's surface but
+ * routes every HTTP call through redcoast. This is the Phase A2 swap —
+ * before this, the iframe held a hardcoded scanner apiKey + consumerId;
+ * now those credentials live in redcoast env vars and the iframe
+ * authenticates via the user's Dynamic JWT (handled by `DynamicApiClient`).
+ *
+ * What stays in the iframe:
+ *   - The `crypto_box_seal` wrap of the view key (`encryptRegistrationRequest`
+ *     from the Provable SDK). The view key plaintext never leaves the
+ *     iframe; only its encrypted form crosses the wire.
+ *
+ * What now lives in redcoast:
+ *   - The Provable Bearer apiKey + consumerId.
+ *   - JWT lifecycle (the SDK used to manage this in the browser; redcoast
+ *     manages it server-side now and the iframe is unaware).
+ *
+ * The class signature intentionally matches the parts of `sdk.RecordScanner`
+ * the iframe consumes (`registerEncrypted`, `findRecords`) so the rest of
+ * `DynamicAleoWalletClient.findOwnedRecordsInner` doesn't change.
+ */ 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 _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(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$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(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 _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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 RedcoastRecordScanner = /*#__PURE__*/ function() {
+    function RedcoastRecordScanner(args) {
+        _class_call_check$1(this, RedcoastRecordScanner);
+        _define_property$1(this, "apiClient", void 0);
+        _define_property$1(this, "network", void 0);
+        _define_property$1(this, "sdk", void 0);
+        this.apiClient = args.apiClient;
+        this.network = args.network;
+        this.sdk = args.sdk;
+    }
+    _create_class$1(RedcoastRecordScanner, [
+        {
+            key: "registerEncrypted",
+            value: /**
+   * Registers an encrypted view key with the scanner. Mirrors
+   * `sdk.RecordScanner.registerEncrypted(viewKey, startBlock)`:
+   *
+   *   1. GET `/scanner/pubkey` → ephemeral public key
+   *   2. Wrap `(viewKey, startBlock)` via libsodium `crypto_box_seal`
+   *   3. POST `/scanner/register` with `{ key_id, ciphertext }`
+   *
+   * Returns the SDK-shaped Result so callers don't have to change.
+   */ function registerEncrypted(viewKey, startBlock) {
+                var _this = this;
+                return _async_to_generator$1(function() {
+                    var pubkey, ciphertext, data, err, _err_response, status, message;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    _this.apiClient.getAleoScannerPubkey({
+                                        network: _this.network
+                                    })
+                                ];
+                            case 1:
+                                pubkey = _state.sent();
+                                ciphertext = _this.sdk.encryptRegistrationRequest(pubkey.public_key, viewKey, startBlock);
+                                return [
+                                    4,
+                                    _this.apiClient.registerAleoScanner({
+                                        network: _this.network,
+                                        keyId: pubkey.key_id,
+                                        ciphertext: ciphertext
+                                    })
+                                ];
+                            case 2:
+                                data = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        ok: true,
+                                        data: data
+                                    }
+                                ];
+                            case 3:
+                                err = _state.sent();
+                                status = (_err_response = err.response) === null || _err_response === void 0 ? void 0 : _err_response.status;
+                                message = _instanceof$1(err, Error) ? err.message : String(err);
+                                return [
+                                    2,
+                                    {
+                                        ok: false,
+                                        status: status,
+                                        error: {
+                                            message: message
+                                        }
+                                    }
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "findRecords",
+            value: /**
+   * Find owned records by uuid. Mirrors the subset of
+   * `sdk.RecordScanner.findRecords(filter)` the iframe consumes.
+   *
+   * The SDK's filter shape is `{ uuid, decrypt, unspent, filter, ... }`.
+   * We forward it verbatim. Records returned are still encrypted on
+   * the wire; the caller (`DynamicAleoWalletClient.findOwnedRecordsInner`)
+   * decrypts them locally with the view key — same as before A2, just
+   * with a different transport underneath.
+   */ function findRecords(filter) {
+                var _this = this;
+                return _async_to_generator$1(function() {
+                    var records;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.apiClient.findAleoScannerRecords({
+                                        network: _this.network,
+                                        filter: filter
+                                    })
+                                ];
+                            case 1:
+                                records = _state.sent().records;
+                                return [
+                                    2,
+                                    Array.isArray(records) ? records : []
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "revoke",
+            value: /** Optional but useful for parity with the SDK; not currently called. */ function revoke(uuid) {
+                var _this = this;
+                return _async_to_generator$1(function() {
+                    return _ts_generator$1(this, function(_state) {
+                        return [
+                            2,
+                            _this.apiClient.revokeAleoScanner({
+                                network: _this.network,
+                                uuid: uuid
+                            })
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return RedcoastRecordScanner;
+}();
+
+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 _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(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);
+    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(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread 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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+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
+        };
+    }
+}
+/**
+ * Feemaster sponsorship for the Aleo `proveTransaction` flow runs through
+ * redcoast as of A1.b. Redcoast holds the ANF Bearer key server-side; the
+ * iframe authenticates with the user's Dynamic JWT. See `feemasterClient.ts`
+ * for the request shape. No API key lives in this bundle anymore.
+ */ /**
+ * Tier-3 stablecoin programs whose `transfer_private` and
+ * `transfer_private_to_public` functions require a Sealance Merkle exclusion
+ * proof for the sender. Programs not in this map skip the proof flow.
+ *
+ * Each entry maps `<stablecoinProgramId> → <freezelistProgramId, network>`.
+ * The freezelist program publishes the BigInt-string Merkle tree at
+ * `/v2/{network}/programs/{freezelist}/compliance/freeze-list` and the
+ * current root at `/program/{freezelist}/mapping/freeze_list_root/1u8`.
+ */ var SEALANCE_PROGRAM_REGISTRY = {
+    test_usad_stablecoin: {
+        freezelistProgram: 'test_usad_freezelist.aleo',
+        network: 'testnet'
+    },
+    test_usdcx_stablecoin: {
+        freezelistProgram: 'test_usdcx_freezelist.aleo',
+        network: 'testnet'
+    },
+    usad_stablecoin: {
+        freezelistProgram: 'usad_freezelist.aleo',
+        network: 'mainnet'
+    },
+    usdcx_stablecoin: {
+        freezelistProgram: 'usdcx_freezelist.aleo',
+        network: 'mainnet'
+    }
+};
+var SEALANCE_FUNCTIONS_REQUIRING_PROOF = new Set([
+    'transfer_private',
+    'transfer_private_to_public'
+]);
+/** Aleo VM input type for the proof argument on Sealance stablecoin programs.
+ *  Verified against `test_usad_stablecoin.aleo` source: `[MerkleProof; 2u32].private`. */ var SEALANCE_PROOF_INPUT_TYPE = '[MerkleProof; 2u32].private';
+/** Tree depth used by the freezelist Merkle tree. Matches the on-chain
+ *  `MerkleProof` struct: `siblings as [field; 16u32]`. */ var SEALANCE_TREE_DEPTH = 16;
+/** Heuristic for deriving the Aleo network from a program ID alone:
+ *  on Aleo, by convention all testnet programs are deployed under a `test_`
+ *  prefix; mainnet programs use the bare name. Both `credits.aleo` and
+ *  `<token>_freezelist.aleo` follow this. */ var networkFromProgramId = function(programId) {
+    return programId.startsWith('test_') ? 'testnet' : 'mainnet';
+};
+/** Aleo numeric network ids (matches the connector's `getSelectedNetwork().chainId`):
+ *   `0` = mainnet, `1` = testnet. The connector + widget pass these in as
+ *   strings or numbers; this helper accepts both shapes. Defaults to testnet
+ *   when undefined / unrecognised so a missing network arg never silently
+ *   switches a session to mainnet. */ var resolveAleoNetwork = function(chainId) {
+    if (chainId === undefined || chainId === null) return 'testnet';
+    var asNumber = typeof chainId === 'number' ? chainId : Number(String(chainId));
+    if (asNumber === 0) return 'mainnet';
+    if (asNumber === 1) return 'testnet';
+    return 'testnet';
+};
+var loadAleoSdk = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(network) {
+        return _ts_generator(this, function(_state) {
+            return [
+                2,
+                network === 'mainnet' ? AleoSdkMainnet__namespace : AleoSdkTestnet__namespace
+            ];
+        });
+    });
+    return function loadAleoSdk(network) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var lookupSealanceConfig = function(programId) {
+    var stem = programId.endsWith('.aleo') ? programId.slice(0, -'.aleo'.length) : programId;
+    return SEALANCE_PROGRAM_REGISTRY[stem];
+};
+var DynamicAleoWalletClient = /*#__PURE__*/ function(DynamicWalletClient) {
+    _inherits(DynamicAleoWalletClient, DynamicWalletClient);
+    function DynamicAleoWalletClient(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, DynamicAleoWalletClient);
+        var _this;
+        _this = _call_super(this, DynamicAleoWalletClient, [
+            {
+                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", 'ALEO'), /**
+   * Cached ProgramManager per Aleo network. The SDK ships separate
+   * mainnet/testnet builds (`@provablehq/sdk/{mainnet,testnet}.js`) that
+   * export network-specific class identities — `ExecutionRequest`,
+   * `ProvingRequest`, etc. each network's prebundle has its own constructor.
+   * `provingRequest` validates `executionRequest instanceof ExecutionRequest`
+   * against the manager's own SDK build, so a manager constructed from the
+   * testnet build will reject a mainnet-built executionRequest (silently
+   * falling into the no-executionRequest branch and throwing a misleading
+   * "No private key provided" error). Caching per network keeps both
+   * builds available and ensures the manager and the executionRequest
+   * always come from the same SDK build.
+   */ _define_property(_this, "programManagersByNetwork", new Map()), /**
+   * Cached RecordScanner instances per Aleo network. Each entry talks to a
+   * single network's scanner endpoint with a single network-specific SDK
+   * build (`@provablehq/sdk/{testnet,mainnet}.js`). Per-wallet identity is
+   * via the scanner UUID cached in walletStateStorage (also keyed by
+   * network). Scanner credentials (apiKey, consumerId) are shared across
+   * networks. The SDK handles JWT refresh automatically.
+   */ _define_property(_this, "scannersByNetwork", new Map()), /**
+   * Cached `FeemasterClient` per Aleo network. Each instance holds an in-
+   * memory policy cache (5 min TTL) and delegates HTTP work to the
+   * inherited `this.apiClient` — the same `DynamicApiClient` every other
+   * iframe→redcoast call uses. So baseApiUrl, auth headers, traceContext
+   * propagation, etc. all come from the existing plumbing for free.
+   */ _define_property(_this, "feemasterClients", new Map()), /**
+   * In-memory cache of program checksums keyed by `${network}:${programId}`.
+   * The Aleo VM's external-signing path requires a non-null `program_checksum`
+   * for any program with a constructor (i.e. anything other than credits.aleo
+   * in our universe). The checksum is immutable for a given deployed program
+   * edition, so we fetch once per session and reuse. Persistence not needed —
+   * a single network round-trip on first use is cheap.
+   */ _define_property(_this, "programChecksumCache", new Map()), /**
+   * Single-flight guard for `findOwnedRecords`, keyed by accountAddress.
+   * The widget's Shielded tab + the demo's "List my records" button can fire
+   * concurrent record scans on the same wallet; without dedup, multiple
+   * findRecords calls race against a stale cached UUID and serially trip
+   * UUIDErrors. With dedup, all concurrent callers await the same in-flight
+   * promise and the recovery path runs at most once.
+   */ _define_property(_this, "pendingFindOwnedRecords", new Map());
+        return _this;
+    }
+    _create_class(DynamicAleoWalletClient, [
+        {
+            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 ceremonyCompleteResolver, ceremonyCompletePromise, serverAccountAddress, _ref, rawPublicKey, clientKeyShares, firstShare, accountAddress, publicKeyHex, pubKeyBytes, error, detail;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                ceremonyCompletePromise = new Promise(function(resolve) {
+                                    ceremonyCompleteResolver = 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
+                                                    ];
+                                                })))
+                                            });
+                                            ceremonyCompleteResolver(undefined);
+                                        },
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), rawPublicKey = _ref.rawPublicKey, clientKeyShares = _ref.clientKeyShares;
+                                return [
+                                    4,
+                                    ceremonyCompletePromise
+                                ];
+                            case 2:
+                                _state.sent();
+                                if (!clientKeyShares || clientKeyShares.length === 0) {
+                                    throw new Error(ERROR_KEYGEN_FAILED);
+                                }
+                                // Aleo addresses come from the Sodot EdBls12377 keygen result directly
+                                // (keygenResult.address is the bech32 `aleo1...` address).
+                                // Prefer the server-provided address if present; otherwise read from the local keygen result.
+                                firstShare = clientKeyShares[0];
+                                accountAddress = serverAccountAddress !== null && serverAccountAddress !== void 0 ? serverAccountAddress : firstShare.address;
+                                if (!accountAddress) {
+                                    throw new Error(ERROR_KEYGEN_FAILED);
+                                }
+                                return [
+                                    4,
+                                    _this.setClientKeySharesToStorage({
+                                        accountAddress: accountAddress,
+                                        clientKeyShares: clientKeyShares,
+                                        overwriteOrMerge: 'overwrite'
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    4,
+                                    _this.storeEncryptedBackupByWallet({
+                                        accountAddress: accountAddress,
+                                        clientKeyShares: clientKeyShares,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 4:
+                                _state.sent();
+                                // For Aleo, `rawPublicKey` from the base keygen is the EdBls12377 computeKey hex.
+                                // There's no separate public-key-to-address derivation — the address is baked into
+                                // the keygen result. Keep the hex for backup/reconstruction purposes.
+                                publicKeyHex = typeof rawPublicKey === 'string' ? rawPublicKey : '';
+                                pubKeyBytes = publicKeyHex ? Buffer.from(publicKeyHex, 'hex') : new Uint8Array();
+                                return [
+                                    2,
+                                    {
+                                        accountAddress: accountAddress,
+                                        publicKeyHex: publicKeyHex,
+                                        rawPublicKey: new Uint8Array(pubKeyBytes)
+                                    }
+                                ];
+                            case 5:
+                                error = _state.sent();
+                                if (_instanceof(error, Error) && error.message === browser.ERROR_PASSWORD_MISMATCH) {
+                                    throw error;
+                                }
+                                _this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+                                detail = _instanceof(error, Error) ? error.message : String(error);
+                                throw new Error("".concat(ERROR_CREATE_WALLET_ACCOUNT, ": ").concat(detail));
+                            case 6:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "signMessage",
+            value: // Phase 1 does not implement arbitrary-message signing for Aleo.
+            // Sodot's EdBls12377 signer only exposes `signRequest(payload)` for Aleo transaction
+            // authorization today — no plain `sign(bytes)` for native Aleo Schnorr signatures.
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            function signMessage(_args) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        throw new Error(ERROR_SIGN_MESSAGE_NOT_SUPPORTED);
+                    });
+                })();
+            }
+        },
+        {
+            key: "signTransaction",
+            value: // signTransaction for Aleo uses the Sodot EdBls12377 `signRequest` ceremony.
+            // That ceremony isn't wired up yet — coming in Phase 2 alongside transfer_public
+            // and the other credits.aleo functions.
+            function signTransaction(args) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        if (!(args === null || args === void 0 ? void 0 : args.accountAddress)) {
+                            throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                        }
+                        throw new Error(ERROR_SIGN_TRANSACTION_NOT_SUPPORTED);
+                    });
+                })();
+            }
+        },
+        {
+            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 derivedPrivateKey, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                if (!accountAddress) {
+                                    throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                                }
+                                return [
+                                    4,
+                                    _this.exportKey({
+                                        accountAddress: accountAddress,
+                                        chainName: _this.chainName,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                derivedPrivateKey = _state.sent().derivedPrivateKey;
+                                if (!derivedPrivateKey) {
+                                    throw new Error('Derived private key is undefined');
+                                }
+                                // For Aleo, `derivedPrivateKey` is the raw hex scalar produced by Sodot's
+                                // EdBls12377 exportFullPrivateKey. Aleo's canonical format is `APrivateKey1...`
+                                // (bech32-encoded via @provablehq/sdk). Encoding to that format requires the
+                                // Provable SDK and is done by the consumer (connector) for now.
+                                return [
+                                    2,
+                                    derivedPrivateKey
+                                ];
+                            case 2:
+                                error = _state.sent();
+                                if (_instanceof(error, Error) && error.message === browser.ERROR_PASSWORD_MISMATCH) {
+                                    throw error;
+                                }
+                                _this.logger.error(ERROR_EXPORT_PRIVATE_KEY, error);
+                                throw new Error(ERROR_EXPORT_PRIVATE_KEY);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "importPrivateKey",
+            value: // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            function importPrivateKey(_args) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        throw new Error(ERROR_IMPORT_PRIVATE_KEY_NOT_SUPPORTED);
+                    });
+                })();
+            }
+        },
+        {
+            key: "getAleoWallets",
+            value: function getAleoWallets() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var wallets;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.getWallets()
+                                ];
+                            case 1:
+                                wallets = _state.sent();
+                                return [
+                                    2,
+                                    wallets.filter(function(wallet) {
+                                        return wallet.chainName === _this.chainName;
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "signAleoRequest",
+            value: /**
+   * Runs the Aleo signRequest MPC ceremony for the given structured payload.
+   * The payload is Sodot's `EdBls12377RequestSignPayload` shape:
+   * { function_id, is_root, program_checksum, inputs: [...] }.
+   * Returns the signed request with { signature, tvk, signer, gammas? } which
+   * the caller passes to `buildExecutionRequestFromExternallySignedData` to
+   * produce an ExecutionRequest for proving via Provable DPS.
+   */ function signAleoRequest(param) {
+                var accountAddress = param.accountAddress, payload = param.payload, _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 wallet, mpcSigner, reconstructedKeyShare, wirePayload, roomId, signedRequest;
+                    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();
+                                return [
+                                    4,
+                                    _this.getWallet({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 2:
+                                wallet = _state.sent();
+                                mpcSigner = browser.getMPCSigner({
+                                    chainName: _this.chainName,
+                                    baseRelayUrl: _this.baseMPCRelayApiUrl
+                                });
+                                return [
+                                    4,
+                                    _this.getReconstructedKeyShare(accountAddress, mpcSigner)
+                                ];
+                            case 3:
+                                reconstructedKeyShare = _state.sent();
+                                // HTTP transport cannot carry Uint8Arrays — hex-encode for the wire.
+                                // The server decodes back to Uint8Array before calling Sodot, so both
+                                // parties end up signing the same byte arrays.
+                                wirePayload = (typeof payload === "undefined" ? "undefined" : _type_of(payload)) === 'object' && payload !== null && 'function_id' in payload ? _this.encodePayloadForTransport(payload) : payload;
+                                return [
+                                    4,
+                                    _this.apiClient.signAleoRequest({
+                                        walletId: wallet.walletId,
+                                        payload: wirePayload,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 4:
+                                roomId = _state.sent().roomId;
+                                return [
+                                    4,
+                                    mpcSigner.signRequest(roomId, reconstructedKeyShare, payload)
+                                ];
+                            case 5:
+                                signedRequest = _state.sent();
+                                if (!signedRequest) {
+                                    throw new Error('Aleo signRequest returned empty — MPC ceremony failed');
+                                }
+                                return [
+                                    2,
+                                    signedRequest
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getViewKeyCacheStorageKey",
+            value: /**
+   * LocalStorage key for caching the per-account Aleo view key in the iframe.
+   * Scoped to iframe origin — the DApp cannot read this via same-origin policy.
+   */ function getViewKeyCacheStorageKey(accountAddress) {
+                return "dynamic-aleo-view-key:".concat(accountAddress);
+            }
+        },
+        {
+            key: "exportViewKey",
+            value: /**
+   * Returns the Aleo view key for the given account. On first call runs the
+   * asymmetric exportViewKey MPC ceremony (client receives, server gets
+   * nothing) and caches the result in iframe localStorage. Subsequent calls
+   * return the cached value. View key never leaves the iframe — it is NOT
+   * postMessage'd to the DApp.
+   */ function exportViewKey(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 cacheKey, _globalThis_localStorage, cached, wallet, mpcSigner, reconstructedKeyShare, exportId, roomId, viewKey, _globalThis_localStorage1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!accountAddress) {
+                                    throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                                }
+                                cacheKey = _this.getViewKeyCacheStorageKey(accountAddress);
+                                try {
+                                    ;
+                                    cached = (_globalThis_localStorage = globalThis.localStorage) === null || _globalThis_localStorage === void 0 ? void 0 : _globalThis_localStorage.getItem(cacheKey);
+                                    if (cached) return [
+                                        2,
+                                        cached
+                                    ];
+                                } catch (e) {
+                                // localStorage unavailable (SSR / sandboxed) — fall through to ceremony.
+                                }
+                                return [
+                                    4,
+                                    _this.verifyPassword({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    4,
+                                    _this.getWallet({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId
+                                    })
+                                ];
+                            case 2:
+                                wallet = _state.sent();
+                                // Re-use the base-class MPC signer + key-share reconstruction so this path
+                                // doesn't duplicate storage logic. The mpcSigner here is an EdBls12377.
+                                mpcSigner = browser.getMPCSigner({
+                                    chainName: _this.chainName,
+                                    baseRelayUrl: _this.baseMPCRelayApiUrl
+                                });
+                                return [
+                                    4,
+                                    _this.getReconstructedKeyShare(accountAddress, mpcSigner)
+                                ];
+                            case 3:
+                                reconstructedKeyShare = _state.sent();
+                                return [
+                                    4,
+                                    _this.getExportId({
+                                        chainName: _this.chainName,
+                                        clientKeyShare: reconstructedKeyShare
+                                    })
+                                ];
+                            case 4:
+                                exportId = _state.sent();
+                                return [
+                                    4,
+                                    _this.apiClient.exportAleoViewKey({
+                                        walletId: wallet.walletId,
+                                        exportId: exportId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 5:
+                                roomId = _state.sent().roomId;
+                                return [
+                                    4,
+                                    mpcSigner.exportViewKey(roomId, reconstructedKeyShare, exportId)
+                                ];
+                            case 6:
+                                viewKey = _state.sent();
+                                if (!viewKey) {
+                                    throw new Error('Aleo view key export returned empty — MPC ceremony failed');
+                                }
+                                try {
+                                    ;
+                                    (_globalThis_localStorage1 = globalThis.localStorage) === null || _globalThis_localStorage1 === void 0 ? void 0 : _globalThis_localStorage1.setItem(cacheKey, viewKey);
+                                } catch (e) {
+                                // best-effort cache — fine to proceed without persistence.
+                                }
+                                return [
+                                    2,
+                                    viewKey
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "toRequestSignPayload",
+            value: /**
+   * Convert a Provable `ExternalSigningInput<'bytes'>` into the Sodot
+   * EdBls12377 signing payload shape. Mirrors the playground helper.
+   * All Uint8Array fields are preserved — this shape is passed directly to
+   * `mpcSigner.signRequest` locally. For HTTP transport, use
+   * `encodePayloadForTransport` to hex-encode the byte fields.
+   */ function toRequestSignPayload(signingInputs) {
+                var _signingInputs_checksum;
+                return {
+                    function_id: signingInputs.functionId,
+                    is_root: signingInputs.isRoot,
+                    program_checksum: (_signingInputs_checksum = signingInputs.checksum) !== null && _signingInputs_checksum !== void 0 ? _signingInputs_checksum : null,
+                    inputs: signingInputs.requestInputs.map(function(requestInput) {
+                        if (requestInput.signingInputType === 'record') {
+                            return {
+                                type: 'record',
+                                h: requestInput.h,
+                                tag: requestInput.tag
+                            };
+                        }
+                        return {
+                            type: requestInput.signingInputType,
+                            index: requestInput.index,
+                            fields: requestInput.data
+                        };
+                    })
+                };
+            }
+        },
+        {
+            key: "encodePayloadForTransport",
+            value: /**
+   * Hex-encode the Uint8Array fields of an EdBls12377 signing payload so it
+   * can travel through JSON HTTP without loss. Mirror of
+   * `decodeAleoSigningPayload` in wallet-service — both sides must agree on
+   * the wire format so the MPC ceremony sees identical byte arrays.
+   */ function encodePayloadForTransport(payload) {
+                var u8ToHex = function(u8) {
+                    return Array.from(u8, function(b) {
+                        return b.toString(16).padStart(2, '0');
+                    }).join('');
+                };
+                return {
+                    function_id: u8ToHex(payload.function_id),
+                    is_root: payload.is_root,
+                    program_checksum: payload.program_checksum == null ? null : u8ToHex(payload.program_checksum),
+                    inputs: payload.inputs.map(function(input) {
+                        if (input.type === 'record') {
+                            return {
+                                type: 'record',
+                                h: u8ToHex(input.h),
+                                tag: u8ToHex(input.tag)
+                            };
+                        }
+                        return {
+                            type: input.type,
+                            index: u8ToHex(input.index),
+                            fields: input.fields.map(function(f) {
+                                return u8ToHex(f);
+                            })
+                        };
+                    })
+                };
+            }
+        },
+        {
+            key: "getProgramChecksum",
+            value: /**
+   * Fetches the on-chain `program_checksum` for a deployed program and
+   * returns it as a 32-byte `Uint8Array` ready to feed into
+   * `computeExternalSigningInputs({ checksum })` and Sodot's
+   * `signRequest` payload (`program_checksum` field).
+   *
+   * Why we need this: the Aleo VM's external-signing path checks the
+   * program checksum for any program that has a constructor. Constructor-
+   * less programs (`credits.aleo`, `token_registry.aleo`) deploy without a
+   * `program_checksum` field and work with `checksum: null`. Programs with
+   * a constructor (USAD/USDCx Tier-3 stablecoins, any custom program)
+   * trip a hardcoded `"Program ID must be credits.aleo"` error in the WASM
+   * unless a real checksum is supplied.
+   *
+   * Returns `null` when the deployment has no checksum (constructor-less);
+   * caller is expected to pass that `null` through to `signRequest`.
+   *
+   * Source: the deployment transaction's `deployment.program_checksum`
+   * field, returned as a 32-element array of `<n>u8` literals (e.g.
+   * `["207u8", "221u8", ...]`).
+   */ function getProgramChecksum(programId, network) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _txJson_deployment, cacheKey, cached, apiBase, txIdRes, txId, txRes, txJson, checksumU8s, _JSON_stringify, bytes, i, match;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                cacheKey = "".concat(network, ":").concat(programId);
+                                cached = _this.programChecksumCache.get(cacheKey);
+                                if (cached !== undefined) return [
+                                    2,
+                                    cached
+                                ];
+                                apiBase = "https://api.explorer.provable.com/v2/".concat(network);
+                                return [
+                                    4,
+                                    fetch("".concat(apiBase, "/find/transactionID/deployment/").concat(programId))
+                                ];
+                            case 1:
+                                txIdRes = _state.sent();
+                                if (!txIdRes.ok) {
+                                    throw new Error("Failed to look up deployment transaction for ".concat(programId, " on ").concat(network, ": HTTP ").concat(txIdRes.status));
+                                }
+                                return [
+                                    4,
+                                    txIdRes.text()
+                                ];
+                            case 2:
+                                txId = _state.sent().replaceAll(/^"|"$/g, '').trim();
+                                // Aleo deployment transaction IDs are bech32-encoded strings prefixed with
+                                // `at1`. Validate before interpolating into the next URL so a corrupted or
+                                // malicious upstream response can't redirect the request elsewhere.
+                                if (!/^at1[a-z0-9]{40,200}$/.test(txId)) {
+                                    throw new Error("Invalid deployment transaction ID format for ".concat(programId, ": ").concat(txId.slice(0, 60)));
+                                }
+                                return [
+                                    4,
+                                    fetch("".concat(apiBase, "/transaction/").concat(txId))
+                                ];
+                            case 3:
+                                txRes = _state.sent();
+                                if (!txRes.ok) {
+                                    throw new Error("Failed to fetch deployment transaction ".concat(txId, ": HTTP ").concat(txRes.status));
+                                }
+                                return [
+                                    4,
+                                    txRes.json()
+                                ];
+                            case 4:
+                                txJson = _state.sent();
+                                checksumU8s = txJson === null || txJson === void 0 ? void 0 : (_txJson_deployment = txJson.deployment) === null || _txJson_deployment === void 0 ? void 0 : _txJson_deployment.program_checksum;
+                                if (checksumU8s == null) {
+                                    // Constructor-less program — checksum is genuinely absent on-chain.
+                                    _this.programChecksumCache.set(cacheKey, null);
+                                    return [
+                                        2,
+                                        null
+                                    ];
+                                }
+                                if (!Array.isArray(checksumU8s) || checksumU8s.length !== 32) {
+                                    throw new Error("Unexpected program_checksum shape for ".concat(programId, ": expected 32-byte array, got ").concat((_JSON_stringify = JSON.stringify(checksumU8s)) === null || _JSON_stringify === void 0 ? void 0 : _JSON_stringify.slice(0, 100)));
+                                }
+                                bytes = new Uint8Array(32);
+                                for(i = 0; i < 32; i += 1){
+                                    match = /^(\d+)u8$/.exec(String(checksumU8s[i]));
+                                    if (!match) {
+                                        throw new Error("Invalid u8 literal at index ".concat(i, " of program_checksum for ").concat(programId, ": ").concat(checksumU8s[i]));
+                                    }
+                                    bytes[i] = Number.parseInt(match[1], 10);
+                                }
+                                _this.programChecksumCache.set(cacheKey, bytes);
+                                return [
+                                    2,
+                                    bytes
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getSealanceProof",
+            value: /**
+   * Computes (or returns from cache) the Sealance Merkle exclusion proof
+   * for `accountAddress` against the given freezelist program's tree.
+   *
+   * The Sealance flow proves the sender is *not* on the freeze list. Recipe:
+   *   1. Fetch the BigInt-string tree at
+   *      `/v2/{network}/programs/{freezelist}/compliance/freeze-list`.
+   *   2. `tree[tree.length - 1]` is the Merkle root.
+   *   3. `convertTreeToBigInt` → `getLeafIndices(addr)` → 2× `getSiblingPath`
+   *      → `formatMerkleProof` produces the formatted `[MerkleProof; 2u32]` literal.
+   *
+   * Cached per (accountAddress, freezelistProgram, root). On the next spend
+   * we only refetch the tree and rebuild when the root has changed.
+   */ function getSealanceProof(param) {
+                var accountAddress = param.accountAddress, freezelistProgram = param.freezelistProgram, network = param.network;
+                return _async_to_generator(function() {
+                    var url, response, treeStrings, currentRoot, cached, _cached_sealanceProofs, cachedProofs, cachedEntry, sdk, sealance, tree, _sealance_getLeafIndices, leftIdx, rightIdx, proofLeft, proofRight, formattedProof, _cached_records, _cached_spentNonces, _cached_lastScannedBlock;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // Defense-in-depth: TS types don't enforce at runtime, so validate the
+                                // path segments before interpolating into the explorer URL.
+                                if (network !== 'testnet' && network !== 'mainnet') {
+                                    throw new Error("Invalid network for Sealance proof: ".concat(network));
+                                }
+                                if (!/^\w+\.aleo$/.test(freezelistProgram)) {
+                                    throw new Error("Invalid freezelist program ID: ".concat(freezelistProgram));
+                                }
+                                url = "https://api.explorer.provable.com/v2/".concat(network, "/programs/").concat(freezelistProgram, "/compliance/freeze-list");
+                                return [
+                                    4,
+                                    fetch(url)
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                if (!response.ok) {
+                                    throw new Error("Failed to fetch Sealance freeze list (".concat(freezelistProgram, ", ").concat(network, "): HTTP ").concat(response.status));
+                                }
+                                return [
+                                    4,
+                                    response.json()
+                                ];
+                            case 2:
+                                treeStrings = _state.sent();
+                                if (!Array.isArray(treeStrings) || treeStrings.length === 0) {
+                                    throw new Error("Sealance freeze list response for ".concat(freezelistProgram, " on ").concat(network, " is empty or malformed."));
+                                }
+                                currentRoot = treeStrings.at(-1);
+                                return [
+                                    4,
+                                    getWalletState(accountAddress, network)
+                                ];
+                            case 3:
+                                cached = _state.sent();
+                                cachedProofs = (_cached_sealanceProofs = cached === null || cached === void 0 ? void 0 : cached.sealanceProofs) !== null && _cached_sealanceProofs !== void 0 ? _cached_sealanceProofs : {};
+                                cachedEntry = cachedProofs[freezelistProgram];
+                                if ((cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.root) === currentRoot) {
+                                    return [
+                                        2,
+                                        cachedEntry.formattedProof
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    loadAleoSdk(network)
+                                ];
+                            case 4:
+                                sdk = _state.sent();
+                                sealance = new sdk.SealanceMerkleTree();
+                                tree = sealance.convertTreeToBigInt(treeStrings);
+                                _sealance_getLeafIndices = _sliced_to_array(sealance.getLeafIndices(tree, accountAddress), 2), leftIdx = _sealance_getLeafIndices[0], rightIdx = _sealance_getLeafIndices[1];
+                                proofLeft = sealance.getSiblingPath(tree, leftIdx, SEALANCE_TREE_DEPTH);
+                                proofRight = sealance.getSiblingPath(tree, rightIdx, SEALANCE_TREE_DEPTH);
+                                formattedProof = sealance.formatMerkleProof([
+                                    proofLeft,
+                                    proofRight
+                                ]);
+                                return [
+                                    4,
+                                    putWalletState(accountAddress, network, {
+                                        scannerUuid: cached === null || cached === void 0 ? void 0 : cached.scannerUuid,
+                                        records: (_cached_records = cached === null || cached === void 0 ? void 0 : cached.records) !== null && _cached_records !== void 0 ? _cached_records : '[]',
+                                        spentNonces: (_cached_spentNonces = cached === null || cached === void 0 ? void 0 : cached.spentNonces) !== null && _cached_spentNonces !== void 0 ? _cached_spentNonces : [],
+                                        lastScannedBlock: (_cached_lastScannedBlock = cached === null || cached === void 0 ? void 0 : cached.lastScannedBlock) !== null && _cached_lastScannedBlock !== void 0 ? _cached_lastScannedBlock : 0,
+                                        sealanceProofs: _object_spread_props(_object_spread({}, cachedProofs), _define_property({}, freezelistProgram, {
+                                            root: currentRoot,
+                                            formattedProof: formattedProof,
+                                            computedAt: Date.now()
+                                        }))
+                                    })
+                                ];
+                            case 5:
+                                _state.sent();
+                                return [
+                                    2,
+                                    formattedProof
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "proveTransaction",
+            value: /**
+   * Full Aleo transaction flow:
+   *   viewKey (MPC exported, cached) → computeExternalSigningInputs
+   *   → Sodot signAleoRequest MPC ceremony
+   *   → buildExecutionRequestFromExternallySignedData
+   *   → Provable DPS submitProvingRequest (computes ZK proof + broadcasts)
+   *
+   * Handles both non-record functions (transfer_public) and record-consuming
+   * functions (transfer_private, join, transfer_public_to_private).
+   *
+   * For Sealance-compliant tier-3 stablecoins (USAD, USDCx), the iframe also
+   * auto-fetches/computes the Merkle exclusion proof and appends it to
+   * `inputs`/`inputTypes` when the program/function pair calls for it. The
+   * caller passes the same shape as a credits.aleo transfer.
+   *
+   * @param broadcast - if true, DPS broadcasts the transaction and returns a
+   *   txId. If false, DPS returns the proving response and the caller
+   *   decides what to do with it.
+   */ function proveTransaction(param) {
+                var accountAddress = param.accountAddress, programId = param.programId, functionName = param.functionName, inputs = param.inputs, inputTypes = param.inputTypes, _param_broadcast = param.broadcast, broadcast = _param_broadcast === void 0 ? true : _param_broadcast, _param_password = param.password, password = _param_password === void 0 ? undefined : _param_password, signedSessionId = param.signedSessionId, mfaToken = param.mfaToken, elevatedAccessToken = param.elevatedAccessToken, chainId = param.chainId;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var viewKey, txNetwork, sdk, programManager, _ref, effectiveInputs, effectiveInputTypes, checksum, signingInputs, payload, signedRequest, executionRequestBase, executionRequest, provingRequest, provingResult, _provingResult_transaction;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!accountAddress) {
+                                    throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                                }
+                                return [
+                                    4,
+                                    _this.exportViewKey({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                viewKey = _state.sent();
+                                // Network resolution: prefer the caller-supplied chainId. The
+                                // `networkFromProgramId` heuristic only works for programs whose
+                                // name varies by network (`test_` prefix on stablecoins / ARC-21);
+                                // it can't disambiguate `credits.aleo`. We trust the caller first
+                                // and only fall back to the heuristic when chainId is omitted.
+                                txNetwork = chainId !== undefined && chainId !== null ? resolveAleoNetwork(chainId) : networkFromProgramId(programId);
+                                return [
+                                    4,
+                                    loadAleoSdk(txNetwork)
+                                ];
+                            case 2:
+                                sdk = _state.sent();
+                                return [
+                                    4,
+                                    _this.getProgramManager(txNetwork)
+                                ];
+                            case 3:
+                                programManager = _state.sent();
+                                return [
+                                    4,
+                                    _this.injectSealanceProofIfNeeded({
+                                        accountAddress: accountAddress,
+                                        functionName: functionName,
+                                        inputTypes: inputTypes,
+                                        inputs: inputs,
+                                        programId: programId
+                                    })
+                                ];
+                            case 4:
+                                _ref = _state.sent(), effectiveInputs = _ref.inputs, effectiveInputTypes = _ref.inputTypes;
+                                return [
+                                    4,
+                                    _this.deriveProgramChecksumField({
+                                        programId: programId,
+                                        sdk: sdk,
+                                        txNetwork: txNetwork
+                                    })
+                                ];
+                            case 5:
+                                checksum = _state.sent();
+                                return [
+                                    4,
+                                    sdk.computeExternalSigningInputs({
+                                        programName: programId,
+                                        functionName: functionName,
+                                        inputs: effectiveInputs,
+                                        inputTypes: effectiveInputTypes,
+                                        isRoot: true,
+                                        checksum: checksum,
+                                        viewKey: viewKey,
+                                        outputFormat: 'bytes'
+                                    })
+                                ];
+                            case 6:
+                                signingInputs = _state.sent();
+                                payload = _this.toRequestSignPayload(signingInputs);
+                                return [
+                                    4,
+                                    _this.signAleoRequest({
+                                        accountAddress: accountAddress,
+                                        payload: payload,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 7:
+                                signedRequest = _state.sent();
+                                executionRequestBase = {
+                                    programId: programId,
+                                    functionName: functionName,
+                                    inputs: effectiveInputs,
+                                    inputTypes: effectiveInputTypes,
+                                    signature: signedRequest.signature,
+                                    tvk: signedRequest.tvk,
+                                    signer: signedRequest.signer,
+                                    skTag: signingInputs.skTag
+                                };
+                                // Use the viewKey strategy — works for all function shapes:
+                                //   - record-consuming: SDK derives recordViewKeys from the viewKey
+                                //   - record-producing: gammas feed the output record's commitment derivation
+                                //   - pure-public: both are no-ops, safe to pass
+                                // `signedRequest.gammas` comes from the MPC signature and is required
+                                // whenever the circuit references any record (input or output).
+                                executionRequest = sdk.buildExecutionRequestFromExternallySignedData(executionRequestBase, {
+                                    viewKey: viewKey,
+                                    gammas: signedRequest.gammas
+                                });
+                                return [
+                                    4,
+                                    _this.buildProvingRequest({
+                                        broadcast: broadcast,
+                                        effectiveInputs: effectiveInputs,
+                                        executionRequest: executionRequest,
+                                        functionName: functionName,
+                                        programId: programId,
+                                        programManager: programManager,
+                                        sdk: sdk,
+                                        txNetwork: txNetwork
+                                    })
+                                ];
+                            case 8:
+                                provingRequest = _state.sent();
+                                return [
+                                    4,
+                                    programManager.networkClient.submitProvingRequest({
+                                        provingRequest: provingRequest,
+                                        dpsPrivacy: true
+                                    })
+                                ];
+                            case 9:
+                                provingResult = _state.sent();
+                                if (broadcast) {
+                                    return [
+                                        2,
+                                        {
+                                            txId: provingResult === null || provingResult === void 0 ? void 0 : (_provingResult_transaction = provingResult.transaction) === null || _provingResult_transaction === void 0 ? void 0 : _provingResult_transaction.id
+                                        }
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    {
+                                        provingResponse: provingResult
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "injectSealanceProofIfNeeded",
+            value: /**
+   * Sealance auto-injection. For tier-3 stablecoin transfer functions that
+   * require a freeze-list exclusion proof, append the formatted
+   * `[MerkleProof; 2u32].private` literal to inputs/inputTypes. Programs
+   * not in the registry / function not requiring proof → pass-through.
+   */ function injectSealanceProofIfNeeded(param) {
+                var accountAddress = param.accountAddress, functionName = param.functionName, inputTypes = param.inputTypes, inputs = param.inputs, programId = param.programId;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var sealanceConfig, proof;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                sealanceConfig = lookupSealanceConfig(programId);
+                                if (!sealanceConfig || !SEALANCE_FUNCTIONS_REQUIRING_PROOF.has(functionName)) {
+                                    return [
+                                        2,
+                                        {
+                                            inputTypes: inputTypes,
+                                            inputs: inputs
+                                        }
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    _this.getSealanceProof({
+                                        accountAddress: accountAddress,
+                                        freezelistProgram: sealanceConfig.freezelistProgram,
+                                        network: sealanceConfig.network
+                                    })
+                                ];
+                            case 1:
+                                proof = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        inputTypes: _to_consumable_array(inputTypes).concat([
+                                            SEALANCE_PROOF_INPUT_TYPE
+                                        ]),
+                                        inputs: _to_consumable_array(inputs).concat([
+                                            proof
+                                        ])
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "deriveProgramChecksumField",
+            value: /**
+   * Derive the program-checksum `Field` snarkVM's external-signing path
+   * needs for non-credits programs. `credits.aleo` is special-cased in the
+   * WASM and works with `null`. Other programs: fetch the on-chain 32-byte
+   * checksum, expand bytes → bits LE, truncate to `Field::SIZE_IN_DATA_BITS`
+   * (252 for Fr), and call `Field.fromBitsLe` — mirrors snarkVM's own
+   * `Stack::program_checksum_as_field`.
+   */ function deriveProgramChecksumField(param) {
+                var programId = param.programId, sdk = param.sdk, txNetwork = param.txNetwork;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var checksumBytes, bits, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, byte, i, SIZE_IN_DATA_BITS;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (programId === 'credits.aleo') return [
+                                    2,
+                                    null
+                                ];
+                                return [
+                                    4,
+                                    _this.getProgramChecksum(programId, txNetwork)
+                                ];
+                            case 1:
+                                checksumBytes = _state.sent();
+                                if (checksumBytes === null) return [
+                                    2,
+                                    null
+                                ];
+                                bits = [];
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = checksumBytes[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        byte = _step.value;
+                                        for(i = 0; i < 8; i += 1){
+                                            bits.push((byte >> i & 1) === 1);
+                                        }
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                                // Aleo's `Field` is the BLS12-377 scalar field Fr (252 data bits).
+                                SIZE_IN_DATA_BITS = 252;
+                                return [
+                                    2,
+                                    sdk.Field.fromBitsLe(bits.slice(0, SIZE_IN_DATA_BITS))
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "buildProvingRequest",
+            value: /**
+   * Build the proving request — feemaster path when ANF covers the
+   * (programId, functionName), user-paid fallback otherwise. Feemaster
+   * failures fall through silently so a transient policy/quota issue
+   * doesn't block the user; they just pay the fee themselves.
+   */ function buildProvingRequest(param) {
+                var broadcast = param.broadcast, effectiveInputs = param.effectiveInputs, executionRequest = param.executionRequest, functionName = param.functionName, programId = param.programId, programManager = param.programManager, sdk = param.sdk, txNetwork = param.txNetwork;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var feemaster, _tmp, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                feemaster = _this.getFeemasterClient(txNetwork);
+                                _tmp = feemaster;
+                                if (!_tmp) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    feemaster.isCovered(programId, functionName)
+                                ];
+                            case 1:
+                                _tmp = _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                if (!_tmp) return [
+                                    3,
+                                    6
+                                ];
+                                _state.label = 3;
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                return [
+                                    4,
+                                    _this.buildFeemasterProvingRequest({
+                                        broadcast: broadcast,
+                                        executionRequest: executionRequest,
+                                        feemaster: feemaster,
+                                        programId: programId,
+                                        programManager: programManager,
+                                        sdk: sdk
+                                    })
+                                ];
+                            case 4:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 5:
+                                err = _state.sent();
+                                // eslint-disable-next-line no-console
+                                console.warn('[aleo:proveTransaction] Feemaster path failed; falling back to user-paid fee', err);
+                                return [
+                                    3,
+                                    6
+                                ];
+                            case 6:
+                                // User-paid fee path. The SDK's `provingRequest` short-circuits its
+                                //  private-key check when `executionRequest` is provided — it forwards
+                                //  the already-MPC-signed request straight to
+                                //  `WasmProgramManager.buildProvingRequestFromExecutionRequest`.
+                                return [
+                                    2,
+                                    programManager.provingRequest({
+                                        programName: programId,
+                                        functionName: functionName,
+                                        inputs: effectiveInputs,
+                                        priorityFee: 0,
+                                        privateFee: false,
+                                        broadcast: broadcast,
+                                        executionRequest: executionRequest
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "buildFeemasterProvingRequest",
+            value: /**
+   * Feemaster-sponsored proving request. Builds the user authorization via
+   * the WASM-direct ProgramManager static (no private key needed — the
+   * request is already MPC-signed), exchanges it with the Feemaster for a
+   * `feeAuthorization`, and returns the bundled `ProvingRequest`.
+   */ function buildFeemasterProvingRequest(param) {
+                var broadcast = param.broadcast, executionRequest = param.executionRequest, feemaster = param.feemaster, programId = param.programId, programManager = param.programManager, sdk = param.sdk;
+                return _async_to_generator(function() {
+                    var networkClient, programSrc, edition, importedPrograms, authorization, feeAuthorizationString, feeAuthorization;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                networkClient = programManager.networkClient;
+                                return [
+                                    4,
+                                    networkClient.getProgram(programId)
+                                ];
+                            case 1:
+                                programSrc = _state.sent();
+                                return [
+                                    4,
+                                    networkClient.getLatestProgramEdition(programId)
+                                ];
+                            case 2:
+                                edition = _state.sent();
+                                return [
+                                    4,
+                                    networkClient.getProgramImports(programId).catch(function() {
+                                        return undefined;
+                                    })
+                                ];
+                            case 3:
+                                importedPrograms = _state.sent();
+                                return [
+                                    4,
+                                    sdk.ProgramManagerBase.buildAuthorizationFromExecutionRequest(executionRequest, programSrc, /* unchecked */ true, edition, importedPrograms, /* private_key */ null)
+                                ];
+                            case 4:
+                                authorization = _state.sent();
+                                return [
+                                    4,
+                                    feemaster.requestFeeAuthorization({
+                                        authorizationString: authorization.toString()
+                                    })
+                                ];
+                            case 5:
+                                feeAuthorizationString = _state.sent().feeAuthorizationString;
+                                feeAuthorization = sdk.Authorization.fromString(feeAuthorizationString);
+                                return [
+                                    2,
+                                    sdk.ProvingRequest.new(authorization, feeAuthorization, broadcast)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "isFeemasterCovered",
+            value: /**
+   * Standalone Feemaster coverage check for any (programId, functionName)
+   * pair on the connector-selected network. Used by the widget to decide
+   * whether a user-paid confirmation modal is needed before triggering a
+   * shield/send/join. Resolves the network from the caller-supplied
+   * `chainId`; defaults to testnet when omitted (mirrors `resolveAleoNetwork`).
+   *
+   * Never throws — returns `false` on any policy fetch failure so callers
+   * can default to "show modal" rather than silently shielding.
+   */ function isFeemasterCovered(param) {
+                var programId = param.programId, functionName = param.functionName, chainId = param.chainId;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var network, feemaster;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                network = chainId !== undefined && chainId !== null ? resolveAleoNetwork(chainId) : 'testnet';
+                                feemaster = _this.getFeemasterClient(network);
+                                if (!feemaster) return [
+                                    2,
+                                    false
+                                ];
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    feemaster.isCovered(programId, functionName)
+                                ];
+                            case 2:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    2,
+                                    false
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getProgramManager",
+            value: /**
+   * Lazy-load the network-matching `@provablehq/sdk` build, instantiate a
+   * ProgramManager, and cache it. The Provable WASM bundle is ~20MB, so
+   * we avoid loading it eagerly at iframe init; both networks' bundles
+   * load on first use of each.
+   */ function getProgramManager(network) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var cached, sdk, programManager, sameOriginProxy;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                cached = _this.programManagersByNetwork.get(network);
+                                if (cached) return [
+                                    2,
+                                    cached
+                                ];
+                                return [
+                                    4,
+                                    loadAleoSdk(network)
+                                ];
+                            case 1:
+                                sdk = _state.sent();
+                                programManager = new sdk.ProgramManager();
+                                // accelerate.provable.com rejects the SDK's X-Aleo-* headers via CORS and
+                                // ships `Access-Control-Allow-Origin: *` alongside `credentials: include`
+                                // (incompatible). In dev, route through the iframe host's Vite proxy
+                                // (`/aleo-dps`) so the browser sees same-origin calls. In prod, the iframe
+                                // host must proxy `/aleo-dps/*` to accelerate.provable.com.
+                                sameOriginProxy = typeof globalThis !== 'undefined' && globalThis.location ? "".concat(globalThis.location.origin, "/aleo-dps") : DEFAULT_PROVABLE_PROVER_URI;
+                                programManager.networkClient.setProverUri(sameOriginProxy);
+                                _this.programManagersByNetwork.set(network, programManager);
+                                return [
+                                    2,
+                                    programManager
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getFeemasterClient",
+            value: function getFeemasterClient(network) {
+                var cached = this.feemasterClients.get(network);
+                if (cached) return cached;
+                var client = new FeemasterClient({
+                    apiClient: this.apiClient,
+                    network: network
+                });
+                this.feemasterClients.set(network, client);
+                return client;
+            }
+        },
+        {
+            key: "getRecordScanner",
+            value: /**
+   * Lazy-init RecordScanner for the given Aleo network using the shared
+   * Provable consumer credentials (VITE_ALEO_SCANNER_API_KEY +
+   * VITE_ALEO_SCANNER_CONSUMER_ID in iframe env). Scanner calls and JWT
+   * refresh both route through the Vite dev proxy `/aleo-api/*` to work
+   * around Provable's CORS 401 on preflight.
+   *
+   * The Provable SDK ships separate `testnet.js` / `mainnet.js` builds
+   * (verified in `node_modules/@provablehq/sdk/package.json#exports`). Each
+   * build pins the chain endpoints to that network, so the right scanner
+   * comes from importing the matching build. We cache an instance per
+   * network on `this.scannersByNetwork`; toggling networks at runtime is
+   * a Map lookup, no teardown.
+   */ function getRecordScanner(network) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var cached, sdk, scanner;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                cached = _this.scannersByNetwork.get(network);
+                                if (cached) return [
+                                    2,
+                                    cached
+                                ];
+                                return [
+                                    4,
+                                    loadAleoSdk(network)
+                                ];
+                            case 1:
+                                sdk = _state.sent();
+                                scanner = new RedcoastRecordScanner({
+                                    apiClient: _this.apiClient,
+                                    network: network,
+                                    sdk: sdk
+                                });
+                                _this.scannersByNetwork.set(network, scanner);
+                                return [
+                                    2,
+                                    scanner
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "findOwnedRecords",
+            value: /**
+   * List all Aleo records owned by this wallet across every program (credits,
+   * custom tokens, etc.). Uses Provable's hosted RecordScanner with our shared
+   * consumer; per-wallet scanner UUID is cached in iframe IndexedDB
+   * (walletStateStorage) so subsequent calls skip the register step.
+   *
+   * Each returned record carries `program_name` + `record_name` so callers
+   * can classify by token. Credits records additionally get a `microcredits`
+   * field parsed in-iframe for convenience (public WASM primitive). Other
+   * tokens are returned as-is — the caller is responsible for amount parsing
+   * per program schema.
+   *
+   * Records are decrypted locally in the iframe via view-key only.
+   * Spent-tracking filters out locally-known spent nonces (records we
+   * consumed in our own proveTransaction calls, before the scanner has
+   * re-indexed).
+   */ function findOwnedRecords(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var accountAddress, chainId, network, dedupeKey, inflight, promise;
+                    return _ts_generator(this, function(_state) {
+                        accountAddress = params.accountAddress, chainId = params.chainId;
+                        if (!accountAddress) {
+                            throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+                        }
+                        // Dedupe concurrent scans on the same (wallet, network) so the recovery
+                        // path runs at most once. Including the network in the key lets a user
+                        // who toggles networks in flight kick off one scan per network without
+                        // the second being absorbed into the first.
+                        network = resolveAleoNetwork(chainId);
+                        dedupeKey = "".concat(accountAddress, ":").concat(network);
+                        inflight = _this.pendingFindOwnedRecords.get(dedupeKey);
+                        if (inflight) return [
+                            2,
+                            inflight
+                        ];
+                        promise = _this.findOwnedRecordsInner(params).finally(function() {
+                            _this.pendingFindOwnedRecords.delete(dedupeKey);
+                        });
+                        _this.pendingFindOwnedRecords.set(dedupeKey, promise);
+                        return [
+                            2,
+                            promise
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "findOwnedRecordsInner",
+            value: function findOwnedRecordsInner(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, chainId = param.chainId;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var viewKey, network, sdk, cached, _cached_spentNonces, spentNonces, _ref, ownedRecords, scannerUuid, viewKeyObj, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, record, filtered, _cached_lastScannedBlock;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.exportViewKey({
+                                        accountAddress: accountAddress,
+                                        password: password,
+                                        signedSessionId: signedSessionId,
+                                        mfaToken: mfaToken,
+                                        elevatedAccessToken: elevatedAccessToken
+                                    })
+                                ];
+                            case 1:
+                                viewKey = _state.sent();
+                                network = resolveAleoNetwork(chainId);
+                                return [
+                                    4,
+                                    _this.loadAleoSdkOrThrow(network)
+                                ];
+                            case 2:
+                                sdk = _state.sent();
+                                return [
+                                    4,
+                                    _this.loadWalletStateOrThrow(accountAddress, network)
+                                ];
+                            case 3:
+                                cached = _state.sent();
+                                spentNonces = (_cached_spentNonces = cached === null || cached === void 0 ? void 0 : cached.spentNonces) !== null && _cached_spentNonces !== void 0 ? _cached_spentNonces : [];
+                                return [
+                                    4,
+                                    _this.findRecordsWithUuidRetry({
+                                        accountAddress: accountAddress,
+                                        cached: cached,
+                                        network: network,
+                                        sdk: sdk,
+                                        spentNonces: spentNonces,
+                                        viewKey: viewKey
+                                    })
+                                ];
+                            case 4:
+                                _ref = _state.sent(), ownedRecords = _ref.records, scannerUuid = _ref.scannerUuid;
+                                // Decrypt + annotate (microcredits / amount) per record so the DApp
+                                // doesn't need the Provable WASM in its own bundle.
+                                viewKeyObj = sdk.ViewKey.from_string(viewKey);
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = ownedRecords[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        record = _step.value;
+                                        _this.enrichOwnedRecord(record, sdk, viewKeyObj);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                                filtered = _this.filterUnspentRecords(ownedRecords, sdk, spentNonces);
+                                // Persist the fresh set so subsequent calls can return immediately if
+                                // the scanner is unreachable.
+                                return [
+                                    4,
+                                    putWalletState(accountAddress, network, {
+                                        scannerUuid: scannerUuid,
+                                        records: JSON.stringify(filtered),
+                                        spentNonces: spentNonces,
+                                        lastScannedBlock: (_cached_lastScannedBlock = cached === null || cached === void 0 ? void 0 : cached.lastScannedBlock) !== null && _cached_lastScannedBlock !== void 0 ? _cached_lastScannedBlock : 0
+                                    })
+                                ];
+                            case 5:
+                                _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        records: filtered
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "loadAleoSdkOrThrow",
+            value: /**
+   * Loads the network-specific Provable SDK build and surfaces a clear
+   * error log to the iframe console when WASM init fails (so the failure
+   * is debuggable; the throw still propagates).
+   */ function loadAleoSdkOrThrow(network) {
+                return _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,
+                                    loadAleoSdk(network)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 2:
+                                err = _state.sent();
+                                // eslint-disable-next-line no-console
+                                console.error('[aleo-client:findOwnedRecordsInner] loadAleoSdk FAILED', {
+                                    network: network,
+                                    error: _instanceof(err, Error) ? err.message : String(err)
+                                });
+                                throw err;
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "loadWalletStateOrThrow",
+            value: /**
+   * Reads the per-(account, network) wallet state from IndexedDB. Errors
+   * are logged and rethrown — a wedged IDB blocks the find-records flow
+   * entirely, so silent fallback isn't safe here.
+   */ function loadWalletStateOrThrow(accountAddress, network) {
+                return _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,
+                                    getWalletState(accountAddress, network)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 2:
+                                err = _state.sent();
+                                // eslint-disable-next-line no-console
+                                console.error('[aleo-client:findOwnedRecordsInner] getWalletState FAILED', {
+                                    error: _instanceof(err, Error) ? err.message : String(err)
+                                });
+                                throw err;
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "findRecordsWithUuidRetry",
+            value: /**
+   * Provable's RecordScanner can throw a `UUIDError` for several reasons —
+   * cached UUID expired server-side, consumer key rotated, scanner instance
+   * stale after a JWT refresh blip. Recovery: drop the cached scanner
+   * instance + cached UUID, re-register, retry up to twice. After that the
+   * problem isn't UUID-related and we surface the underlying error.
+   */ function findRecordsWithUuidRetry(param) {
+                var accountAddress = param.accountAddress, cached = param.cached, network = param.network, sdk = param.sdk, spentNonces = param.spentNonces, viewKey = param.viewKey;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var registerWallet, tryFind, _cached_scannerUuid, scannerUuid, _tmp, lastErr, attempt, _tmp1, err, _cached_records, _cached_lastScannedBlock;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                registerWallet = /*#__PURE__*/ function() {
+                                    var _ref = _async_to_generator(function() {
+                                        return _ts_generator(this, function(_state) {
+                                            return [
+                                                2,
+                                                _this.registerScannerWallet({
+                                                    accountAddress: accountAddress,
+                                                    cached: cached,
+                                                    network: network,
+                                                    sdk: sdk,
+                                                    spentNonces: spentNonces,
+                                                    viewKey: viewKey
+                                                })
+                                            ];
+                                        });
+                                    });
+                                    return function registerWallet() {
+                                        return _ref.apply(this, arguments);
+                                    };
+                                }();
+                                tryFind = /*#__PURE__*/ function() {
+                                    var _ref = _async_to_generator(function(uuid) {
+                                        var scanner;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    return [
+                                                        4,
+                                                        _this.getRecordScanner(network)
+                                                    ];
+                                                case 1:
+                                                    scanner = _state.sent();
+                                                    return [
+                                                        2,
+                                                        scanner.findRecords({
+                                                            uuid: uuid,
+                                                            decrypt: true,
+                                                            unspent: true,
+                                                            filter: {}
+                                                        })
+                                                    ];
+                                            }
+                                        });
+                                    });
+                                    return function tryFind(uuid) {
+                                        return _ref.apply(this, arguments);
+                                    };
+                                }();
+                                if (!((_cached_scannerUuid = cached === null || cached === void 0 ? void 0 : cached.scannerUuid) !== null && _cached_scannerUuid !== void 0)) return [
+                                    3,
+                                    1
+                                ];
+                                _tmp = _cached_scannerUuid;
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 1:
+                                return [
+                                    4,
+                                    registerWallet()
+                                ];
+                            case 2:
+                                _tmp = _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                scannerUuid = _tmp;
+                                attempt = 0;
+                                _state.label = 4;
+                            case 4:
+                                if (!(attempt < 3)) return [
+                                    3,
+                                    12
+                                ];
+                                _state.label = 5;
+                            case 5:
+                                _state.trys.push([
+                                    5,
+                                    7,
+                                    ,
+                                    11
+                                ]);
+                                _tmp1 = {};
+                                return [
+                                    4,
+                                    tryFind(scannerUuid)
+                                ];
+                            case 6:
+                                return [
+                                    2,
+                                    (_tmp1.records = _state.sent(), _tmp1.scannerUuid = scannerUuid, _tmp1)
+                                ];
+                            case 7:
+                                err = _state.sent();
+                                lastErr = err;
+                                if (!isUuidScannerError(err)) throw err;
+                                // Reset this network's scanner instance + cached UUID, re-register.
+                                _this.scannersByNetwork.delete(network);
+                                return [
+                                    4,
+                                    putWalletState(accountAddress, network, {
+                                        scannerUuid: undefined,
+                                        records: (_cached_records = cached === null || cached === void 0 ? void 0 : cached.records) !== null && _cached_records !== void 0 ? _cached_records : '[]',
+                                        spentNonces: spentNonces,
+                                        lastScannedBlock: (_cached_lastScannedBlock = cached === null || cached === void 0 ? void 0 : cached.lastScannedBlock) !== null && _cached_lastScannedBlock !== void 0 ? _cached_lastScannedBlock : 0
+                                    })
+                                ];
+                            case 8:
+                                _state.sent();
+                                return [
+                                    4,
+                                    new Promise(function(resolve) {
+                                        return setTimeout(resolve, 100);
+                                    })
+                                ];
+                            case 9:
+                                _state.sent();
+                                return [
+                                    4,
+                                    registerWallet()
+                                ];
+                            case 10:
+                                scannerUuid = _state.sent();
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 11:
+                                attempt += 1;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 12:
+                                throw new Error("Aleo RecordScanner kept rejecting the wallet UUID after re-registering. Try refreshing the page; underlying error: ".concat(_instanceof(lastErr, Error) ? lastErr.message : String(lastErr)));
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "registerScannerWallet",
+            value: /**
+   * Wraps the encrypted view key and registers it with the scanner.
+   * `registerEncrypted` (not `register`) ensures the view key crosses the
+   * wire encrypted; same pattern Provable's `example-autojoin` uses.
+   */ function registerScannerWallet(param) {
+                var accountAddress = param.accountAddress, cached = param.cached, network = param.network, sdk = param.sdk, spentNonces = param.spentNonces, viewKey = param.viewKey;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var scanner, regResult, _regResult_error, _regResult_status, status, _regResult_error_message, newUuid, _cached_records, _cached_lastScannedBlock;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.getRecordScanner(network)
+                                ];
+                            case 1:
+                                scanner = _state.sent();
+                                return [
+                                    4,
+                                    scanner.registerEncrypted(sdk.ViewKey.from_string(viewKey), 0)
+                                ];
+                            case 2:
+                                regResult = _state.sent();
+                                if (!(regResult === null || regResult === void 0 ? void 0 : regResult.ok)) {
+                                    status = (_regResult_status = regResult === null || regResult === void 0 ? void 0 : regResult.status) !== null && _regResult_status !== void 0 ? _regResult_status : 'unknown';
+                                    throw new Error((_regResult_error_message = regResult === null || regResult === void 0 ? void 0 : (_regResult_error = regResult.error) === null || _regResult_error === void 0 ? void 0 : _regResult_error.message) !== null && _regResult_error_message !== void 0 ? _regResult_error_message : "register failed (".concat(status, ")"));
+                                }
+                                newUuid = regResult.data.uuid;
+                                return [
+                                    4,
+                                    putWalletState(accountAddress, network, {
+                                        scannerUuid: newUuid,
+                                        records: (_cached_records = cached === null || cached === void 0 ? void 0 : cached.records) !== null && _cached_records !== void 0 ? _cached_records : '[]',
+                                        spentNonces: spentNonces,
+                                        lastScannedBlock: (_cached_lastScannedBlock = cached === null || cached === void 0 ? void 0 : cached.lastScannedBlock) !== null && _cached_lastScannedBlock !== void 0 ? _cached_lastScannedBlock : 0
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    2,
+                                    newUuid
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "enrichOwnedRecord",
+            value: /**
+   * Decrypt the record's ciphertext locally (when missing) and surface
+   * `microcredits` / `amount` as decimal strings so the DApp side can
+   * display balances without needing the Provable WASM in its own bundle.
+   * Mutates the record in place — same contract the original loop had.
+   */ function enrichOwnedRecord(record, sdk, viewKeyObj) {
+                if (!record.record_plaintext && record.record_ciphertext) {
+                    try {
+                        var ciphertext = sdk.RecordCiphertext.fromString(record.record_ciphertext);
+                        record.record_plaintext = ciphertext.decrypt(viewKeyObj).toString();
+                    } catch (e) {
+                    // Wrong view key or malformed ciphertext — record stays without
+                    // plaintext (renders as "#N" in the UI).
+                    }
+                }
+                var isCreditsRecord = record.program_name === 'credits.aleo' && record.record_name === 'credits';
+                if (isCreditsRecord && record.record_plaintext && !record.microcredits) {
+                    try {
+                        var plaintext = sdk.RecordPlaintext.fromString(record.record_plaintext);
+                        record.microcredits = plaintext.microcredits().toString();
+                    } catch (e) {
+                    /* ignore — malformed plaintext */ }
+                    return;
+                }
+                // Non-credits Token records (stablecoins / ARC-21) carry their balance
+                // in an `amount` field of type `u128.private`. `getMember('amount')`
+                // returns e.g. "100u128.private" — strip the type suffix.
+                if (!isCreditsRecord && record.record_plaintext && !record.amount) {
+                    try {
+                        var plaintext1 = sdk.RecordPlaintext.fromString(record.record_plaintext);
+                        var amountLiteral = plaintext1.getMember('amount').toString();
+                        var numericMatch = /^(\d+)/.exec(amountLiteral);
+                        if (numericMatch) {
+                            record.amount = numericMatch[1];
+                        }
+                    } catch (e) {
+                    /* not a Token record with an amount field — skip */ }
+                }
+            }
+        },
+        {
+            key: "filterUnspentRecords",
+            value: /**
+   * Local spent-nonce filter — protects against the race where we've
+   * broadcast a record-spending transaction but the scanner hasn't indexed
+   * the spend yet.
+   */ function filterUnspentRecords(records, sdk, spentNonces) {
+                var nonceOf = function(r) {
+                    try {
+                        if (r.record_plaintext) {
+                            return sdk.RecordPlaintext.fromString(r.record_plaintext).nonce();
+                        }
+                    } catch (e) {
+                    /* ignore */ }
+                    return undefined;
+                };
+                return records.filter(function(r) {
+                    var n = nonceOf(r);
+                    return !n || !spentNonces.includes(n);
+                });
+            }
+        }
+    ]);
+    return DynamicAleoWalletClient;
+}(browser.DynamicWalletClient);
+/**
+ * `findOwnedRecordsInner` retries on a UUID-stale signal — match the SDK's
+ * own `UUIDError` message and the redcoast 422 forwarding (controller wraps
+ * Provable's 422 with a "UUID invalid" body); plus any HTTP 422 on this
+ * endpoint always indicates a stale/unknown UUID per Provable's contract.
+ */ var isUuidScannerError = function(err) {
+    var _err_response;
+    var msg = _instanceof(err, Error) ? err.message : String(err);
+    var _err_response_status;
+    var status = (_err_response_status = err === null || err === void 0 ? void 0 : (_err_response = err.response) === null || _err_response === void 0 ? void 0 : _err_response.status) !== null && _err_response_status !== void 0 ? _err_response_status : err === null || err === void 0 ? void 0 : err.status;
+    return /UUID/i.test(msg) || status === 422;
+};
+
+exports.ALEO_NETWORKS = ALEO_NETWORKS;
+exports.DynamicAleoWalletClient = DynamicAleoWalletClient;