AutistMask/src/shared/state.js

// State management and extension storage persistence.

const { DEFAULT_RPC_URL, DEFAULT_BLOCKSCOUT_URL } = require("./constants");
const { networkById } = require("./networks");
// Dependency-free constant module; safe to pull into a background bundle.
const { RESTORABLE_VIEWS } = require("../popup/restorableViews");

const { storageGet, storageSet } = require("./browserApi");
const { log } = require("./log");

const DEFAULT_STATE = {
    hasWallet: false,
    wallets: [],
    trackedTokens: [],
    networkId: "mainnet",
    rpcUrl: DEFAULT_RPC_URL,
    blockscoutUrl: DEFAULT_BLOCKSCOUT_URL,
    // Endpoints remembered per network: { [networkId]: { rpcUrl,
    // blockscoutUrl } }. rpcUrl/blockscoutUrl above are the live endpoints
    // of the active network; this is what the others are restored from
    // when the active network changes. See onChainSwitch().
    networkEndpoints: {},
    lastBalanceRefresh: 0,
    activeAddress: null,
    allowedSites: {},
    deniedSites: {},
    rememberSiteChoice: true,
    showZeroBalanceTokens: true,
    hideSpoofedSymbols: true,
    hideLowHolderTokens: true,
    hideFraudContracts: true,
    hideDustTransactions: true,
    dustThresholdGwei: 100000,
    utcTimestamps: false,
    fraudContracts: [],
    tokenHolderCache: {},
    theme: "system",
    debugMode: false,
};

const state = {
    ...DEFAULT_STATE,
    // Its own object, not the one DEFAULT_STATE holds: onChainSwitch()
    // mutates this map in place, and a spread copies the reference.
    networkEndpoints: {},
    currentView: null,
    selectedWallet: null,
    selectedAddress: null,
    selectedToken: null,
    viewData: {},
    viewStack: [],
};

// Keep only the leading run of stored views the popup is willing to render.
//
// restoreView() refuses to reopen ONTO a non-restorable view, but the stack
// behind it used to be restored verbatim, so Back could walk onto a screen
// whose content is deliberately never re-rendered — and "show-phrase" has no
// Back control to leave by. Truncating at the first such entry instead of
// splicing it out keeps the result a prefix of the stored stack, so every
// surviving entry's Back target is exactly the one it had; splicing would
// silently re-point the entry above the hole at a different screen.
//
// Filtering happens here on load rather than in saveState(): the live
// in-session stack is legitimate (the screen really is rendered while the
// popup is open), and only a load-side filter also repairs the stacks
// already in storage, including ones written before a view left the set.
function restorableStack(stored, currentView) {
    // A stored stack that is missing or not an array keeps nothing, but it
    // still goes through the never-empty rule below rather than returning
    // early: otherwise a corrupt stack would depend on exactly the goBack()
    // fallback that the explicit ["main"] exists in order not to depend on.
    const source = Array.isArray(stored) ? stored : [];
    const cut = source.findIndex((view) => !RESTORABLE_VIEWS.has(view));
    const kept = cut === -1 ? source.slice() : source.slice(0, cut);
    // A view restored below the root still needs somewhere for Back to go.
    if (
        kept.length === 0 &&
        currentView !== "main" &&
        RESTORABLE_VIEWS.has(currentView)
    ) {
        return ["main"];
    }
    return kept;
}

// Return the network configuration for the currently selected network.
function currentNetwork() {
    return networkById(state.networkId);
}

// Every field written to and read from the single "autistmask" storage key.
// hasWallet is deliberately excluded from the diffing/merge logic below —
// like loadState() does, it is always derived from `wallets`, never carried
// as an independent value.
const PERSISTED_FIELDS = Object.keys(DEFAULT_STATE)
    .filter((key) => key !== "hasWallet")
    .concat([
        "currentView",
        "selectedWallet",
        "selectedAddress",
        "selectedToken",
        "viewData",
        "viewStack",
    ]);

// Turn a raw stored (or missing) record into the full, defaulted shape
// loadState() used to assign directly onto `state`. Pulled out as a pure
// function so saveState() can apply it too: the fields THIS page did not
// change still have to come from storage in their loaded-and-normalized
// form, not as the raw bytes another page (or an old release) left there —
// otherwise a legacy shape a load has always self-healed in memory (a
// missing networkEndpoints map, an out-of-range flag) is dropped right back
// into storage unfixed every time the page that DID normalize it saves
// something unrelated, because that field's value never "changed" for that
// page to notice.
function normalizePersisted(saved) {
    saved = saved || {};
    const out = {};
    out.wallets = saved.wallets || [];
    // Derived, never trusted verbatim off storage — see loadState().
    out.hasWallet = out.wallets.length > 0;
    out.trackedTokens = saved.trackedTokens || [];
    out.networkId = saved.networkId || DEFAULT_STATE.networkId;
    out.rpcUrl = saved.rpcUrl || DEFAULT_STATE.rpcUrl;
    out.blockscoutUrl = saved.blockscoutUrl || DEFAULT_STATE.blockscoutUrl;
    // An actual object is required, not merely a truthy non-array: the code
    // below and onChainSwitch() index and ASSIGN INTO this value, and
    // assigning a property to a string or a number is a silent no-op in
    // sloppy mode. Copied rather than referenced, nested pairs included, so
    // normalizing never mutates the object a caller handed in.
    const rawEndpoints =
        typeof saved.networkEndpoints === "object" &&
        saved.networkEndpoints !== null &&
        !Array.isArray(saved.networkEndpoints)
            ? saved.networkEndpoints
            : {};
    out.networkEndpoints = {};
    for (const netId of Object.keys(rawEndpoints)) {
        out.networkEndpoints[netId] = { ...rawEndpoints[netId] };
    }
    // A profile written before this map existed carries exactly one pair of
    // endpoints, belonging to whatever network it was last on. Adopt it as
    // that network's remembered pair, so a custom endpoint set on the old
    // build is not lost by the first switch away and back.
    if (!out.networkEndpoints[out.networkId]) {
        out.networkEndpoints[out.networkId] = {
            rpcUrl: out.rpcUrl,
            blockscoutUrl: out.blockscoutUrl,
        };
    }
    out.lastBalanceRefresh = saved.lastBalanceRefresh || 0;
    out.activeAddress = saved.activeAddress || null;
    out.allowedSites =
        saved.allowedSites && !Array.isArray(saved.allowedSites)
            ? saved.allowedSites
            : {};
    out.deniedSites =
        saved.deniedSites && !Array.isArray(saved.deniedSites)
            ? saved.deniedSites
            : {};
    out.rememberSiteChoice =
        saved.rememberSiteChoice !== undefined
            ? saved.rememberSiteChoice
            : true;
    out.showZeroBalanceTokens =
        saved.showZeroBalanceTokens !== undefined
            ? saved.showZeroBalanceTokens
            : true;
    // A profile written before this setting existed has no key for it. It
    // is a safety filter, so absent must load as on, not as undefined.
    out.hideSpoofedSymbols =
        saved.hideSpoofedSymbols !== undefined
            ? saved.hideSpoofedSymbols
            : true;
    out.hideLowHolderTokens =
        saved.hideLowHolderTokens !== undefined
            ? saved.hideLowHolderTokens
            : true;
    out.hideFraudContracts =
        saved.hideFraudContracts !== undefined
            ? saved.hideFraudContracts
            : true;
    out.hideDustTransactions =
        saved.hideDustTransactions !== undefined
            ? saved.hideDustTransactions
            : true;
    out.dustThresholdGwei =
        saved.dustThresholdGwei !== undefined
            ? saved.dustThresholdGwei
            : 100000;
    out.utcTimestamps =
        saved.utcTimestamps !== undefined ? saved.utcTimestamps : false;
    out.fraudContracts = saved.fraudContracts || [];
    out.tokenHolderCache = saved.tokenHolderCache || {};
    out.theme = saved.theme || "system";
    out.debugMode = saved.debugMode !== undefined ? saved.debugMode : false;
    out.currentView = saved.currentView || null;
    out.selectedWallet =
        saved.selectedWallet !== undefined ? saved.selectedWallet : null;
    out.selectedAddress =
        saved.selectedAddress !== undefined ? saved.selectedAddress : null;
    out.selectedToken = saved.selectedToken || null;
    out.viewData = saved.viewData || {};
    out.viewStack = restorableStack(saved.viewStack, out.currentView);
    return out;
}

// The persisted fields as they stood at the end of this page's last
// loadState() or saveState(). saveState() diffs the live state against this
// to find only the fields THIS page actually changed.
//
// Deep-cloned, not a reference: callers mutate persisted objects and arrays
// in place (state.wallets.push(...)), and a reference baseline would mutate
// right along with `state`, so the diff would always come out empty.
let baseline = null;

function snapshotPersisted() {
    const out = {};
    for (const key of PERSISTED_FIELDS) out[key] = state[key];
    return out;
}

function deepEqual(a, b) {
    if (a === b) return true;
    if (typeof a !== "object" || typeof b !== "object") return false;
    if (a === null || b === null) return false;
    if (Array.isArray(a) !== Array.isArray(b)) return false;
    const aKeys = Object.keys(a);
    const bKeys = Object.keys(b);
    if (aKeys.length !== bKeys.length) return false;
    for (const key of aKeys) {
        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
        if (!deepEqual(a[key], b[key])) return false;
    }
    return true;
}

// Stable identity for a wallet, independent of its position in the array
// (which shifts under a concurrent add/delete elsewhere) and independent of
// its mutable fields (name is user-editable; addresses gains/loses entries
// via scanning and deleteAddress.js). An "hd"/"xprv" wallet's xpub never
// changes for its lifetime and is already enforced unique
// (findWalletByXpub() in addWallet.js). A "key" wallet has no xpub, exactly
// one address for its whole lifetime (nothing ever adds to or removes from
// a key wallet's address list), and that address is already enforced
// unique (findWalletByAddress()) — so it stands in for identity there.
// Neither invariant is enforced by this function or by
// mergeListByIdentity() below — they hold only because every wallet-
// creation path in addWallet.js happens to populate one or the other before
// the wallet ever reaches state.wallets, and because canRemoveAddress() in
// walletDelete.js never lets a wallet's address list go to zero. A wallet
// with neither (an empty/legacy/corrupt record) falls back to the same
// "addr:" identity as every other such record, which is a genuine
// collision, not a proxy for one — see the collision handling in
// mergeListByIdentity().
function walletIdentity(wallet) {
    if (wallet.xpub) return "xpub:" + wallet.xpub;
    const first = wallet.addresses && wallet.addresses[0];
    return "addr:" + (first ? String(first.address).toLowerCase() : "");
}

// Stable identity for an address within one wallet's address list. An
// address is unique within its wallet and, once derived or imported, never
// changes — only whether it is present.
function addressIdentity(addr) {
    return String(addr.address).toLowerCase();
}

// Merge one array of identity-bearing objects (wallets, or the addresses
// inside one wallet) by identity rather than by array index — an index
// shifts under a concurrent insert/delete elsewhere, which would merge the
// wrong pair of objects entirely.
//
// `theirs` (fresh storage) sets the membership baseline and the order:
//   - An item this page never had baseline knowledge of, but that is in
//     `theirs`, was added by someone else — kept as-is.
//   - An item `base` had and `ours` no longer has was deleted by THIS page
//     — dropped even though `theirs` still has it (this page's own delete
//     must win over a background save that only touched leaf fields).
//   - An item present in both `ours` and `theirs` is merged leaf-by-leaf via
//     `mergeItem`, so a leaf this page changed (e.g. a renamed wallet) lands
//     on top of `theirs`' otherwise-current copy (e.g. a refreshed balance).
// Anything left in `ours` that `base` never had and `theirs` does not have
// yet is this page's own new addition — appended.
//
// `identityOf` is not guaranteed collision-free (walletIdentity() falls
// back to one shared "addr:" value for any wallet with neither an xpub nor
// a populated first address). Two records that collide under it must never
// silently collapse into one — that is exactly how this function used to
// drop a wallet, encryptedSecret included, with no error and no log. Two
// defenses:
//   - `ours` is indexed into GROUPS, not a single item per identity, so two
//     colliding live items on this page can't overwrite each other in the
//     index before the merge below even runs.
//   - A matched pair with no shared `base` entry (neither page ever agreed
//     on this identity) is only merged leaf-by-leaf when the two sides are
//     already equal. If they differ, that is not "the same record edited
//     twice", it is two different records that happen to share an identity
//     — both are kept, unmerged, rather than guessing which one is real.
function mergeListByIdentity(base, ours, theirs, identityOf, mergeItem) {
    base = base || [];
    ours = ours || [];
    theirs = theirs || [];
    const baseIndex = new Map(base.map((item) => [identityOf(item), item]));
    const oursIndex = new Map();
    for (const item of ours) {
        const id = identityOf(item);
        if (!oursIndex.has(id)) oursIndex.set(id, []);
        oursIndex.get(id).push(item);
    }

    const result = [];
    const seen = new Set();

    for (const theirItem of theirs) {
        const id = identityOf(theirItem);
        seen.add(id);
        const oursGroup = oursIndex.get(id);
        if (baseIndex.has(id) && !oursGroup) continue;
        if (oursGroup) {
            const baseItem = baseIndex.get(id);
            if (!baseItem && !deepEqual(oursGroup[0], theirItem)) {
                log.errorf(
                    "state: identity collision merging",
                    JSON.stringify(id),
                    "- keeping both records instead of dropping one",
                );
                result.push(theirItem, ...oursGroup);
            } else {
                result.push(mergeItem(baseItem, oursGroup[0], theirItem));
                for (let i = 1; i < oursGroup.length; i++) {
                    result.push(oursGroup[i]);
                }
            }
        } else {
            result.push(theirItem);
        }
    }

    for (const item of ours) {
        const id = identityOf(item);
        if (seen.has(id)) continue;
        if (!baseIndex.has(id)) result.push(item);
    }

    return result;
}

// Merge one wallet's scalar/leaf fields (name, encryptedSecret, nextIndex,
// ...) against base, then recurse into its address list by identity. `base`
// is null when this page created the wallet itself and no other page has
// (yet) produced a same-identity record — nothing to merge in that case,
// this page's own copy wins outright. mergeListByIdentity() only ever calls
// this with `!base` when `ours` and `theirs` are already equal (a genuine
// collision between two DIFFERENT same-identity records is caught and kept
// as two separate entries before this function is reached), so returning
// `ours` here can't discard a different wallet's data.
function mergeWallet(base, ours, theirs) {
    if (!base) return ours;
    const merged = { ...theirs };
    for (const key of Object.keys(ours)) {
        if (key === "addresses") continue;
        if (!deepEqual(ours[key], base[key])) merged[key] = ours[key];
    }
    merged.addresses = mergeListByIdentity(
        base.addresses,
        ours.addresses,
        theirs.addresses,
        addressIdentity,
        mergeAddress,
    );
    return merged;
}

// Merge one address's leaf fields (balance, ensName, tokenBalances, ...).
// tokenBalances is itself an array, but only backgroundRefresh() ever
// writes it and always wholesale (refreshBalances() in
// src/shared/balances.js), so there is no membership to reconcile within
// it — it is a leaf like balance or ensName, not a list with its own
// identity.
function mergeAddress(base, ours, theirs) {
    if (!base) return ours;
    const merged = { ...theirs };
    for (const key of Object.keys(ours)) {
        if (!deepEqual(ours[key], base[key])) merged[key] = ours[key];
    }
    return merged;
}

// Merge a plain object keyed by string (allowedSites/deniedSites: address ->
// hostname list; networkEndpoints: networkId -> {rpcUrl, blockscoutUrl}) the
// same way mergeListByIdentity() merges an array — by key, not by whole-
// object diff — so a key one page added or removed applies independently of
// a key another page edited. Unlike an array's identity function, an object
// key can't collide with a different logical entry (Object.keys() is
// already deduplicated), so this needs no collision floor of its own.
function mergeMapByKey(base, ours, theirs, mergeLeaf) {
    base = base || {};
    ours = ours || {};
    theirs = theirs || {};
    const result = {};
    const seen = new Set();

    for (const key of Object.keys(theirs)) {
        seen.add(key);
        const inBase = Object.prototype.hasOwnProperty.call(base, key);
        const inOurs = Object.prototype.hasOwnProperty.call(ours, key);
        if (inBase && !inOurs) continue; // this page deleted the whole entry
        if (inOurs) {
            result[key] = mergeLeaf(base[key], ours[key], theirs[key]);
        } else {
            result[key] = theirs[key];
        }
    }

    for (const key of Object.keys(ours)) {
        if (seen.has(key)) continue;
        if (!Object.prototype.hasOwnProperty.call(base, key)) {
            result[key] = ours[key];
        }
    }

    return result;
}

// allowedSites/deniedSites: { [address]: [hostname, ...] }. The hostname
// list is itself membership, not a leaf — src/background/index.js pushes a
// newly approved/denied hostname onto it in place, and the Settings "revoke"
// button (src/popup/views/settings.js) filters a hostname out of it in
// place, from a different page. Merge it the same way wallets are merged:
// identity is the hostname itself, so a merged pair is always equal and
// mergeItem is a no-op pick.
function mergeHostnameList(base, ours, theirs) {
    return mergeListByIdentity(
        base,
        ours,
        theirs,
        (hostname) => hostname,
        (b, o, t) => t,
    );
}

function mergeSiteMap(base, ours, theirs) {
    return mergeMapByKey(base, ours, theirs, mergeHostnameList);
}

// networkEndpoints: { [networkId]: {rpcUrl, blockscoutUrl} }. onChainSwitch()
// (src/shared/chainSwitch.js) writes state.networkEndpoints[networkId] in
// place before saving. No code path ever removes a key from this map, so the
// membership collision that matters for allowedSites/wallets (an add on one
// page racing a delete on another) can't happen here — but two pages
// switching to two different networks concurrently still race a whole-field
// diff the same way, so it gets the same per-key merge for the leaf edit
// case (e.g. Settings saving a custom RPC URL for the active network).
function mergeEndpointEntry(base, ours, theirs) {
    if (!base) return ours;
    const merged = { ...theirs };
    for (const key of Object.keys(ours)) {
        if (!deepEqual(ours[key], base[key])) merged[key] = ours[key];
    }
    return merged;
}

function mergeNetworkEndpoints(base, ours, theirs) {
    return mergeMapByKey(base, ours, theirs, mergeEndpointEntry);
}

// Read-modify-write, merged per field, rather than one full-blob write.
//
// Every extension page (the toolbar popup, a dApp approval window, the
// background's backgroundRefresh()) holds its own in-memory `state`, loaded
// once, and showView() saves on every navigation. A full-blob write here
// clobbers whatever a second page had written since — including, in the
// worst case, an entire wallet and its encrypted secret with no attacker
// and no unusual input (see the issue this fixes).
//
// Only the fields this page actually changed — those that differ from
// `baseline`, captured at the last loadState()/saveState() on this page —
// are written; every other field is carried forward from whatever is in
// storage right now, which may already be a value another page wrote.
//
// `wallets` is merged structurally (mergeListByIdentity(), by wallet
// identity and then by address identity within each wallet), not as one
// whole field: backgroundRefresh() mutates wallets IN PLACE (addr.balance /
// ensName / tokenBalances, via refreshBalances()), so a whole-field diff
// would mark all of `wallets` "changed" the moment any balance moved and
// write back background's own copy — loaded before its multi-second network
// round trip — clobbering a wallet another page added, or resurrecting one
// another page deleted, in that window. Merging by identity lets
// background's leaf changes and another page's membership changes
// (add/delete a wallet or an address) apply independently instead of
// colliding as the same field.
//
// `allowedSites` and `deniedSites` get the same treatment (mergeSiteMap(),
// by address key and then by hostname within each address's list), for the
// identical reason: src/background/index.js pushes a newly
// approved/denied hostname onto them in place, and the Settings "revoke"
// button (src/popup/views/settings.js) filters one out in place, from a
// different page. A whole-field diff here doesn't just lose data, it is a
// security defect — a stale page's save can resurrect a just-revoked site
// permission, or silently wipe a permission just granted elsewhere.
//
// `networkEndpoints` gets the same treatment too (mergeNetworkEndpoints(),
// by network id), since onChainSwitch() writes into it in place; the value
// per key is a small leaf object with no membership of its own; see the
// comment at mergeEndpointEntry() for why the collision this closes is
// milder than the other two.
//
// Every other persisted field stays a whole-field diff:
// `trackedTokens`/`fraudContracts`/`viewStack` are arrays of scalars with no
// per-element identity to merge by; `tokenHolderCache` is a map shaped like
// the ones above, but nothing in src/ ever writes an entry into it — it is
// only ever reset wholesale to `{}` (onChainSwitch()) — so there is no
// in-place mutation for a whole-field diff to collide with; `viewData` is
// this page's own UI scratch space, not data another page has any reason to
// share membership of.
//
// This does not make two pages that both change the SAME leaf concurrently
// safe: last write wins on that one leaf, same as before. What it removes
// is the cross-field (and now cross-membership-vs-leaf) clobber — a page
// that only navigated, or only refreshed a balance, overwriting a wallet or
// address list it never touched the membership of.
//
// This page's own live `state` is deliberately NOT rehydrated from a field
// another page changed — only the record written to storage is merged.
// showView() fires saveState() on every navigation without awaiting it,
// which is what makes the queue above necessary in the first place, and a
// save that is slow to come back has no way to tell whether the field it
// is about to hand back is still the current answer or has since been
// overtaken by something this very page did in the meantime; writing it
// into `state` regardless reintroduced exactly the clobber this function
// exists to remove, just delayed and confined to one page instead of two
// (caught by tests/txStatus.test.js). A page's live picture of a field it
// does not own goes on being whatever its last loadState() saw, same as
// before this fix; only the persisted record is guaranteed current.
async function saveStateOnce() {
    const current = snapshotPersisted();
    const result = await storageGet("autistmask");
    // Normalized, not raw: a field this page did not change still has to
    // come from storage in its loaded (self-healed) shape. See
    // normalizePersisted() above.
    const fresh = normalizePersisted(result.autistmask);

    const merged = { ...fresh };
    for (const key of PERSISTED_FIELDS) {
        if (key === "wallets") {
            merged.wallets = mergeListByIdentity(
                baseline ? baseline.wallets : [],
                current.wallets,
                fresh.wallets,
                walletIdentity,
                mergeWallet,
            );
        } else if (key === "allowedSites" || key === "deniedSites") {
            merged[key] = mergeSiteMap(
                baseline ? baseline[key] : {},
                current[key],
                fresh[key],
            );
        } else if (key === "networkEndpoints") {
            merged.networkEndpoints = mergeNetworkEndpoints(
                baseline ? baseline.networkEndpoints : {},
                current.networkEndpoints,
                fresh.networkEndpoints,
            );
        } else if (
            baseline === null ||
            !deepEqual(current[key], baseline[key])
        ) {
            merged[key] = current[key];
        }
    }
    merged.hasWallet = Boolean(merged.wallets && merged.wallets.length > 0);

    await storageSet({ autistmask: merged });

    // Derived from this page's own wallets, never adopted off the wire —
    // see loadState(). Everything else this page did not change is left
    // exactly as it stood; see the note above.
    state.hasWallet = state.wallets.length > 0;

    baseline = structuredClone(snapshotPersisted());
}

// showView() calls saveState() on every navigation without awaiting it, so
// two saves from the SAME page can be in flight at once — e.g. a screen
// shown, then immediately replaced before the first save's storageGet()
// round trip has come back. Left concurrent, the first save's turn would
// finish after the second's live-state mutation and then re-hydrate `state`
// from what IT read, stomping the second, later change back to a stale
// value — the same clobber this function exists to prevent, just between
// two saves on one page instead of two pages. Queuing makes every save's
// snapshot-diff-write-rehydrate run start to finish before the next one
// begins, so each one only ever sees the true live state at its turn.
let saveQueue = Promise.resolve();

function saveState() {
    const turn = saveQueue.then(saveStateOnce);
    // The queue must advance even when a save rejects, or every save after
    // it queues behind a promise that never settles.
    saveQueue = turn.catch(() => {});
    return turn;
}

async function loadState() {
    const result = await storageGet("autistmask");
    if (result.autistmask) {
        Object.assign(state, normalizePersisted(result.autistmask));
    }
    // The point of comparison every saveState() on this page diffs against,
    // whether storage had a profile or was empty. See PERSISTED_FIELDS above
    // saveState() for why a reference here would be wrong.
    baseline = structuredClone(snapshotPersisted());
}

function currentAddress() {
    if (state.selectedWallet === null || state.selectedAddress === null) {
        return null;
    }
    return state.wallets[state.selectedWallet].addresses[state.selectedAddress];
}

module.exports = {
    state,
    saveState,
    loadState,
    currentAddress,
    currentNetwork,
};