@zerc20/wallet-sdk 0.2.0 → 0.4.0

package/dist/wallet.js

@@ -1,8 +1,9 @@
 // The wallet an app works with. Amounts are bigints in a token's base units.
-import { CanisterClient, codeKey, commit, decodeCode, encodeCode, lookupRecipient, nextPosLane, planDeposit, planPosLane, posKey, registeredViewKey, } from '@zerc20/storage-sdk';
-import { bytesToHex, formatUnits, hexToBytes, isAddress, numberToHex, zeroAddress, } from 'viem';
+import { CanisterClient, codeKey, commit, decodeCode, encodeCode, lookupRecipient, nextPosLane, notifyKey, planDeposit, planPosLane, posKey, registeredViewKey, } from '@zerc20/storage-sdk';
+import { bytesToHex, formatUnits, getAddress, hexToBytes, isAddress, numberToHex, zeroAddress, } from 'viem';
+import { toAccount } from 'viem/accounts';
 import { Chain, MAX_REFERRAL_BPS, NATIVE, erc20Abi, tokenAbi } from './chain.js';
-import { chainCtx, chainState, spendKey, walletSees } from './context.js';
+import { chainCtx, chainState, owner, switched, walletOn, walletSees, } from './context.js';
 import { burnAddressFor, core, initCore } from './core.js';
 import { WalletError, fail, guard } from './errors.js';
 import { checkNetwork } from './network.js';
@@ -10,9 +11,9 @@ import { Asp, Indexer, PAGE } from './servers.js';
 import { rageExit } from './rageExit.js';
 import { registerDeposit, relayerFees } from './services.js';
 import { advanceSpend, chosenSettling, coins, grossed, inputsOf, landed, maxPayment, mergePool, mergeRound, payWith, planStep, roundsToMerge, settling, withdrawalOf, } from './spend.js';
-import { emptyWalletState, openState, sealState, } from './state.js';
-import { WAIT_MS, commitmentTx, recordBurn, storageState, syncAll, takeRefresh, tokenIds, topUpBurns, unusedBurn, } from './sync.js';
-const DAY_MS = 86_400_000;
+import { emptyWalletState, openState, sealState, stateKey, unspent, } from './state.js';
+import { WAIT_MS, commitmentTx, keyAll, nextBurn, recordBurn, storageState, syncAll, takeRefresh, tokenIds, topUpBurns, unusedBurn, } from './sync.js';
+import { decodeViewKey, encodeViewKey } from './viewKey.js';
 /** The ledger's bound outside an emergency. */
 const NO_BOUND = 2n ** 64n - 1n;
 export class Wallet {
@@ -24,9 +25,12 @@ export class Wallet {
     #busy = 0;
     #release = () => { };
     #referrer;
+    #unlock;
+    #readOnly = false;
     #closed = new AbortController();
-    constructor(ctx) {
+    constructor(ctx, unlock) {
         this.#ctx = ctx;
+        this.#unlock = unlock;
     }
     /** Lets this wallet open again: in another tab, or here for another account. This object is done with: what is
      * queued fails with `wallet-closed`, a burn address search stops, and the wallet is let go once the task under way
@@ -38,12 +42,19 @@ export class Wallet {
     get address() {
         return this.#ctx.address;
     }
+    /** The account's view key, for `watch` to follow it with on another device: whoever holds it sees what this wallet
+     * shows, except the private payments to receive codes, and can spend none of it. Checksummed text (bech32m,
+     * `zerc20view1…`). */
+    viewKey() {
+        return encodeViewKey(this.#ctx.view, owner(this.#ctx));
+    }
+    /** Whether this wallet only watches its account (`watch`): it shows what the account holds and spends nothing. */
+    get readOnly() {
+        return this.#readOnly;
+    }
     /** Opens the wallet. The first time on this address, registers it for payments: one signature. */
     static async open(opts) {
-        await initCore();
         checkNetwork(opts.network);
-        if (opts.seed.length !== 32)
-            fail('invalid', 'the seed is 32 bytes');
         // the factory refuses these, which the relayer would report as its own failure
         const r = opts.referrer;
         if (r) {
@@ -52,67 +63,156 @@ export class Wallet {
             if (!Number.isInteger(r.bps) || r.bps < 0 || r.bps > MAX_REFERRAL_BPS)
                 fail('invalid', `a referrer takes 0 to ${MAX_REFERRAL_BPS} bps, not ${r.bps}`);
         }
-        const account = opts.walletClient.account ?? fail('invalid', 'the wallet client has no account');
+        if (!opts.account === !opts.walletClient)
+            fail('invalid', 'give an account or a wallet client, one of the two');
+        const account = opts.account ?? opts.walletClient.account ?? fail('invalid', 'the wallet client has no account');
+        // asked once the options are checked, and before anything is waited on: a browser shows a passkey prompt only in
+        // the click that opened
+        const seed = typeof opts.seed === 'function' ? await opts.seed() : opts.seed;
+        if (seed.length !== 32)
+            fail('invalid', 'the seed is 32 bytes');
+        await initCore();
         const release = await lockWallet(account.address);
         try {
-            return await Wallet.#open(opts, account, release);
+            return await Wallet.#open(opts, seed, account, release);
         }
         catch (e) {
             release();
             throw e;
         }
     }
-    static async #open(opts, account, release) {
+    static async #open(opts, seed, account, release) {
         const address = account.address;
-        const chains = opts.network.chains.map((config) => ({
-            config,
-            chain: new Chain(config),
-            indexer: new Indexer(config.indexer),
-            asp: new Asp(config.asp),
-        }));
+        const chains = chainsOf(opts.network);
         const code = await chains[0]?.chain.client.getCode({ address });
         // an EIP-7702 delegated account is still an EOA that signs
         if (code && code !== '0x' && !code.startsWith('0xef0100'))
             fail('unsupported-account', 'contract accounts cannot sign for a wallet');
-        const signer = async (message) => hexToBytes(await guard(opts.walletClient.signMessage({ account, message })));
+        const signer = async (message) => hexToBytes(await guard(account.type === 'local'
+            ? account.signMessage({ message })
+            : opts.walletClient.signMessage({ account, message })));
         const storage = await CanisterClient.connect(opts.network.storage.host, opts.network.storage.canisterId);
-        const publicKey = hexToBytes(core.spendKey(opts.seed).publicKey);
+        const publicKey = hexToBytes(core.spendKey(seed).publicKey);
         const saved = await opts.persist.load();
         // registered already: used before, here or on another device, so its past is looked for
         // ponytail: from genesis (~4 MB per million commitments); ask for a birthday once the chain has many
         const restoring = !saved?.length && opts.birthday === undefined && !!(await storage.registration(hexToBytes(address)));
-        const view = await registeredViewKey(storage, opts.seed, signer, hexToBytes(address), publicKey);
-        const loaded = saved?.length ? openState(opts.seed, saved) : null;
-        // never started over in place: the first save would overwrite what it held, operations in flight included
-        if (saved?.length && !loaded) {
-            fail('invalid', 'the saved state does not open with this seed (another seed, a newer version, or damaged): clear it to start over, which finds what it held again');
-        }
-        if (loaded && loaded.address.toLowerCase() !== address.toLowerCase())
-            fail('invalid', `the saved state is ${loaded.address}'s: keep one per address`);
-        const state = loaded ?? emptyWalletState(address);
-        const ctx = {
+        const view = await registeredViewKey(storage, seed, signer, hexToBytes(address), publicKey);
+        const wallet = await Wallet.#begin({
             network: opts.network,
-            seed: opts.seed,
+            seed,
+            owners: new Map(),
             address,
-            walletClient: opts.walletClient,
+            account,
+            walletClient: opts.walletClient ?? null,
             storage,
             view,
             chains,
-            state,
-            save: () => opts.persist.save(sealState(opts.seed, state)),
-            lastFullRefreshMs: 0,
-        };
-        if (!loaded)
-            await start(ctx, restoring ? 0n : opts.birthday);
-        const wallet = new Wallet(ctx);
+        }, { persist: opts.persist, saved, key: stateKey(seed), from: restoring ? 0n : opts.birthday }, typeof opts.seed === 'function' ? opts.seed : undefined);
         wallet.#release = release;
         wallet.#referrer = opts.referrer;
+        return wallet;
+    }
+    /** Opens an account to follow by its view key (`viewKey()`): its balances, coins and history as its own wallet shows
+     * them, less the private payments to its receive codes, whose keys only the seed derives. It spends and writes
+     * nothing: a call that would fails with `read-only`. The key must be the account's current one on this network. */
+    static async watch(opts) {
+        checkNetwork(opts.network);
+        await initCore();
+        const { view, owner } = decodeViewKey(opts.viewKey) ?? fail('invalid', 'not a view key');
+        const address = getAddress(bytesToHex(view.address));
+        const release = await lockWallet(address, 'view');
+        try {
+            const storage = await CanisterClient.connect(opts.network.storage.host, opts.network.storage.canisterId);
+            // what the account signed: a nullifying key that is not the account's would show spent coins as unspent
+            const r = await lookupRecipient(storage, view.address);
+            if (!r || bytesToHex(r.publicKey) !== owner.publicKey || bytesToHex(r.notifyKey) !== bytesToHex(notifyKey(view)))
+                fail('invalid', `not ${address}'s view key on ${opts.network.name}, or one it has replaced`);
+            const wallet = await Wallet.#begin({
+                network: opts.network,
+                seed: null,
+                owners: new Map([['', owner]]),
+                address,
+                // signs nothing: every call that would send is refused first
+                account: toAccount(address),
+                walletClient: null,
+                storage,
+                view,
+                chains: chainsOf(opts.network),
+            }, 
+            // registered, so its past is looked for
+            {
+                persist: opts.persist,
+                saved: await opts.persist.load(),
+                key: stateKey(view.seed),
+                from: opts.birthday ?? 0n,
+            });
+            wallet.#release = release;
+            wallet.#readOnly = true;
+            return wallet;
+        }
+        catch (e) {
+            release();
+            throw e;
+        }
+    }
+    /** The wallet over `base`, its state opened from what `persist` saved, with `key`, or started `from` a block or date. */
+    static async #begin(base, { persist, saved, key, from, }, unlock) {
+        const loaded = saved?.length ? openState(key, saved) : null;
+        // never started over in place: the first save would overwrite what it held, operations in flight included
+        if (saved?.length && !loaded) {
+            fail('invalid', 'the saved state does not open with this key (another seed or view key, a newer version, or damaged): clear it to start over, which finds what it held again');
+        }
+        if (loaded && loaded.address.toLowerCase() !== base.address.toLowerCase())
+            fail('invalid', `the saved state is ${loaded.address}'s: keep one per address`);
+        const state = loaded ?? emptyWalletState(base.address);
+        const ctx = { ...base, state, save: () => persist.save(sealState(key, state)), lastFullRefreshMs: 0 };
+        if (!loaded)
+            await start(ctx, from);
+        const wallet = new Wallet(ctx, unlock);
         // a saved state names its tokens by id, and its coins stand by the chains' roots: read both now, so balances, coins
         // and history work before the first sync
-        const [tokens] = await Promise.all([Promise.all(chains.map((c) => c.chain.tokens())), wallet.#readRoots()]);
+        const [tokens] = await Promise.all([Promise.all(ctx.chains.map((c) => c.chain.tokens())), wallet.#readRoots()]);
         wallet.#tokens = tokens.flat();
+        keyAll(ctx, wallet.#tokens);
         return wallet;
     }
+    /** Holds `seed`, asked of `#unlock`, once it is checked to be this wallet's. */
+    #hold(seed) {
+        if (core.spendKey(seed).publicKey !== owner(this.#ctx).publicKey)
+            fail('invalid', "the seed given is another wallet's");
+        this.#ctx.seed = seed;
+        keyAll(this.#ctx, this.#tokens);
+    }
+    /** Within a task: the seed held, asked of `#unlock` if need be. */
+    async #seed() {
+        if (!this.#ctx.seed)
+            this.#hold(await this.#unlock());
+    }
+    /** At the end of a sync: lets the seed go when it was opened with a function for it, nothing waits behind the sync,
+     * and no payment, withdrawal or consolidation is in flight, as each may sign again (a JoinSplit that reverts is
+     * proved again, and every merge round is signed). */
+    #dropSeed() {
+        if (!this.#unlock || this.#busy > 1)
+            return;
+        if (this.#ctx.state.ops.some((o) => o.status === 'pending' && o.kind !== 'deposit'))
+            return;
+        this.#ctx.seed = null;
+    }
+    /** `#exclusive` for a call that `needs` the seed: held first, asked of `#unlock` if need be before the call waits on
+     * anything else (a browser shows a passkey prompt only in the click that asked), and queued in the step that took it,
+     * so that a sync ending meanwhile does not let it go. */
+    async #seeded(f, needs = true) {
+        this.#writable();
+        if (needs && !this.#ctx.seed)
+            this.#hold(await this.#unlock());
+        return this.#exclusive(f);
+    }
+    /** Refuses a call that spends or writes to storage, in a wallet that watches. */
+    #writable() {
+        if (this.#readOnly)
+            fail('read-only', 'this wallet watches its account by its view key: open it with its seed');
+    }
     /** Runs `f` after everything queued before it: one state, changed by one task at a time. */
     #exclusive(f) {
         this.#busy++;
@@ -145,13 +245,16 @@ export class Wallet {
     }
     /** Catches up: new notes, deposits, spends and roots, then advances every operation in flight. A chain or server that
      * fails holds back only what needs it, and the first error is thrown once the rest is done. Settles before the burn
-     * addresses are topped up, which can take a phone tens of seconds. */
+     * addresses are topped up, which can take a phone some seconds. */
     sync() {
         return new Promise((resolve, reject) => {
             this.#exclusive(async () => {
                 await this.#catchUp().then(resolve, reject);
-                // still this task's: a deposit queued meanwhile finds the one recorded ahead, rather than writing at handout
-                await topUpBurns(this.#ctx, this.#closed.signal).catch(() => { }); // tried again after the next sync
+                // still this task's: a deposit queued meanwhile finds the one recorded ahead, rather than writing at handout;
+                // tried again after the next sync. A wallet that watches records none, as it writes nothing.
+                if (!this.#readOnly)
+                    await topUpBurns(this.#ctx, this.#closed.signal).catch(() => { });
+                this.#dropSeed();
             }).catch(reject); // closed before it ran
         });
     }
@@ -193,7 +296,7 @@ export class Wallet {
         if (errors.length > 0)
             throw errors[0];
     }
-    /** Syncs on its own: every 15 s while something is under way, every 5 min otherwise. Returns a stop function. */
+    /** Syncs on its own: every 3 s while something is under way, every 10 s otherwise. Returns a stop function. */
     autoSync(onChange, onError) {
         let stopped = false;
         let timer;
@@ -208,7 +311,7 @@ export class Wallet {
             if (stopped || this.#closed.signal.aborted)
                 return;
             const busy = this.#ctx.state.ops.some((o) => o.status === 'pending' && Date.now() - o.createdMs < WAIT_MS * 4);
-            timer = setTimeout(tick, busy ? 15_000 : 300_000);
+            timer = setTimeout(tick, busy ? 3_000 : 10_000);
         };
         void tick();
         return () => {
@@ -226,15 +329,16 @@ export class Wallet {
     }
     balances() {
         const coins = this.coins();
+        // storage says which notes to look for, not that they come: a payer writes its notes there before its JoinSplit
+        // leaves, and one that never lands leaves them behind. So a note counts once it is a coin (its commitment read);
+        // before that, only a note this device's own operation under way is making counts, as incoming. A zero-value
+        // change, there to carry its payment's receipt, never counts
+        const making = new Set(this.#ctx.state.ops.flatMap((o) => o.status === 'pending' && o.kind !== 'deposit' ? (o.data.changes ?? []) : []));
         return this.#tokens.map((token) => {
             const { chainId, tokenId } = token;
             const b = { token, spendable: 0n, pending: [], blocked: 0n };
-            // a merge that never landed (another device spent an input first) stops counting after a day; a zero-value
-            // change, there to carry its payment's receipt, never counts. A note is a coin once its commitment is read, so
-            // until then it is incoming, as a payment's change is between its relay and the next sync
-            for (const n of this.#ctx.state.notes.filter((n) => n.chainId === chainId && n.tokenId === tokenId && n.value > 0n)) {
-                const stale = n.receipt?.kind === 'merged' && n.atNs !== null && Date.now() - Number(n.atNs / 1000000n) > DAY_MS;
-                if (!n.found.some((f) => f.confirmed) && !stale)
+            for (const n of this.#ctx.state.notes.filter((n) => n.chainId === chainId && n.tokenId === tokenId && n.value > 0n && making.has(n.salt))) {
+                if (!n.found.some((f) => f.confirmed))
                     b.pending.push({ amount: n.value, reason: 'incoming' });
             }
             for (const c of coins.filter((c) => c.token === token)) {
@@ -249,20 +353,21 @@ export class Wallet {
         });
     }
     /** Every unspent note and deposit on chain, and where each stands, as of opening or the last sync. A note announced
-     * but not on chain yet is not one: `balances()` counts it as incoming. */
+     * but not read on chain yet is not one: `balances()` counts it as incoming if this device's operation is making it. */
     coins() {
         const size = (chainId) => this.#status.get(chainId)?.latestRoot?.size ?? 0;
         const unproved = (chainId) => (this.#status.get(chainId)?.halted ? 'roots-halted' : 'awaiting-root');
         const spending = new Set(this.#ctx.state.ops.flatMap((o) => inputsOf(o).map((c) => `${o.chainId}:${c.index}`)));
-        // spent by a JoinSplit in a block, which waits only to be final: gone, as activity() counts it (a reorg that drops
-        // it brings them back as spending, and the operation relays it again)
+        // spent by a JoinSplit in a block, which waits only to be final: gone, as activity() counts it. Sync sees it by its
+        // nullifier (`unspent`); this device's own is gone already from its relay on (a reorg that drops it brings them
+        // back as spending, and the operation relays it again)
         const landed = new Set(this.#ctx.state.ops.flatMap((o) => o.kind !== 'deposit' && o.data.step?.stage === 'relayed'
             ? inputsOf(o).map((c) => `${o.chainId}:${c.index}`)
             : []));
         const out = [];
         // a zero-value change carries its payment's receipt, and is no coin
         for (const n of this.#ctx.state.notes.filter((n) => n.value > 0n)) {
-            for (const f of n.found.filter((f) => !f.spent)) {
+            for (const f of n.found.filter(unspent)) {
                 const id = `${n.chainId}:${f.index}`;
                 // a 4-byte tag alone matches someone else's now and then: a coin once its commitment is read
                 if (!f.confirmed || landed.has(id))
@@ -281,7 +386,7 @@ export class Wallet {
         }
         for (const d of this.#ctx.state.deposits) {
             // a coin once its commitment is read, which names the amount
-            for (const f of d.found.filter((f) => !f.spent && f.amount !== null)) {
+            for (const f of d.found.filter((f) => unspent(f) && f.amount !== null)) {
                 const id = `${d.chainId}:${f.index}`;
                 if (landed.has(id))
                     continue;
@@ -505,6 +610,7 @@ export class Wallet {
      * addresses. */
     posKey() {
         return this.#exclusive(async () => {
+            this.#writable();
             const ctx = this.#ctx;
             const tokens = await tokenIds(ctx);
             let n = 0;
@@ -518,7 +624,7 @@ export class Wallet {
     /** Refunds deposit `id` to its sender without the ASP, the attester or a proved root: for a deposit the ASP
      * rejected, or when those services stop. The account's wallet sends the transactions and pays their gas. */
     rageExit(id) {
-        return this.#exclusive(async () => {
+        return this.#seeded(async () => {
             const [chain, index] = id.split(':');
             const record = this.#ctx.state.deposits.find((d) => `${d.chainId}` === chain && d.found.some((f) => `${f.index}` === index)) ??
                 fail('invalid', `no deposit ${id}`);
@@ -615,18 +721,22 @@ export class Wallet {
      * With `wrapped`, it pays from the account's zERC20 itself, as a withdrawal pays out, rather than its underlying
      * asset: a plain transfer into the burn address, with no wrap and no approval.
      *
+     * With `from`, another wallet of the user's (a browser wallet) pays instead of the account: its balance is checked,
+     * it approves and wraps, and an exit refunds it there. The account pays nothing and signs nothing.
+     *
      * Returns once the wrap is sent: the operation is done once it is mined, which `wait()` or the next sync finds.
      * `onStep` hears what it waits on meanwhile, for an app to show. */
-    deposit(opts) {
+    async deposit(opts) {
+        this.#writable();
+        if (opts.amount <= 0n)
+            fail('invalid', 'the amount must be positive');
+        const payer = opts.from ? (opts.from.account ?? fail('invalid', 'the wallet client has no account')) : null;
         const step = opts.onStep ?? (() => { });
         if (this.#busy > 0)
             step('queued');
         return this.#exclusive(async () => {
             const { token, amount } = opts;
-            if (amount <= 0n)
-                fail('invalid', 'the amount must be positive');
-            const wc = this.#ctx.walletClient;
-            const account = wc.account;
+            const account = payer ?? this.#ctx.account;
             const client = chainCtx(this.#ctx, token.chainId).chain.client;
             const { wrapped } = opts;
             const native = !wrapped && token.underlying.toLowerCase() === NATIVE.toLowerCase();
@@ -641,7 +751,7 @@ export class Wallet {
                 });
             if (held < amount) {
                 const of = wrapped ? token.symbol : `${token.symbol}'s underlying asset`;
-                fail('insufficient-funds', `the account holds ${formatUnits(held, token.decimals)} of ${of}, less than ${formatUnits(amount, token.decimals)}`);
+                fail('insufficient-funds', `${payer ? 'the wallet' : 'the account'} holds ${formatUnits(held, token.decimals)} of ${of}, less than ${formatUnits(amount, token.decimals)}`);
             }
             const address = opts.to
                 ? await this.#burnFor(token, amount, opts.to, () => step('burn-address'))
@@ -649,8 +759,7 @@ export class Wallet {
             const op = this.#newOp('deposit', token, amount, opts.to ? { burnAddress: address, to: opts.to } : { burnAddress: address });
             await this.#ctx.save();
             try {
-                if ((await wc.getChainId()) !== Number(token.chainId))
-                    await guard(wc.switchChain({ id: Number(token.chainId) }));
+                const wc = opts.from ? await switched(opts.from, token.chainId) : await walletOn(this.#ctx, token.chainId);
                 if (!native && !wrapped) {
                     const allowance = await client.readContract({
                         address: token.underlying,
@@ -742,6 +851,7 @@ export class Wallet {
         if (this.#busy > 0)
             step('queued');
         return this.#exclusive(async () => {
+            this.#writable();
             const c = chainCtx(this.#ctx, token.chainId);
             const record = await this.#burnAddress(token, null, () => step('burn-address'));
             const { depositAddress, fee } = await registerDeposit(c.chain, token.address, record.address, this.address, this.#referrer);
@@ -767,17 +877,22 @@ export class Wallet {
      * nothing; it names neither this address nor its public key. Anyone who gets the code can pay it, and see what its
      * other payers paid privately: give each payer its own. It is checksummed text (bech32m, `zerc201…`). */
     receiveCode(token) {
-        return this.#exclusive(async () => {
-            const ctx = this.#ctx;
+        const ctx = this.#ctx;
+        const code = (index) => ({ chainId: token.chainId, tokenId: token.tokenId, index });
+        // the seed is asked for only past the codes derived ahead
+        const derived = !!owner(ctx, code(nextBurn(ctx, token.chainId, token.tokenId)));
+        return this.#seeded(async () => {
             const { burnIndex, address } = await this.#burnAddress(token);
+            if (!owner(ctx, code(burnIndex)))
+                await this.#seed(); // calls queued before took the next ones
             return encodeCode({
                 chainId: token.chainId,
                 tokenId: token.tokenId,
                 burnAddress: hexToBytes(address),
-                publicKey: hexToBytes(spendKey(ctx, { chainId: token.chainId, tokenId: token.tokenId, index: burnIndex }).publicKey),
+                publicKey: hexToBytes(owner(ctx, code(burnIndex)).publicKey),
                 key: codeKey(ctx.view.seed, token.chainId, token.tokenId, burnIndex),
             });
-        });
+        }, !derived);
     }
     /** What a send or withdrawal of `amount` would cost now, or a consolidation of what the wallet holds. A send or
      * withdrawal no single JoinSplit can pay now throws as it would (`needs-consolidation`, `funds-settling`,
@@ -832,11 +947,12 @@ export class Wallet {
      * what is spendable now, or it fails here: `needs-consolidation`, `funds-settling` or `insufficient-funds`.
      * `amount` is what the recipient gets, and `maxFee` caps what it pays on top, `fees({ kind: 'send' }).fee`: the
      * relayer names its fee, so a quote the user saw is the cap. */
-    send(opts) {
-        return this.#exclusive(async () => {
-            const { token, amount } = opts;
-            if (amount <= 0n)
-                fail('invalid', 'the amount must be positive');
+    async send(opts) {
+        const { token, amount } = opts;
+        if (amount <= 0n)
+            fail('invalid', 'the amount must be positive');
+        // the JoinSplit is proved by a later sync, which holds the seed until the payment is done
+        return this.#seeded(async () => {
             let to;
             if (isAddress(opts.to)) {
                 const recipient = await lookupRecipient(this.#ctx.storage, hexToBytes(opts.to));
@@ -866,7 +982,7 @@ export class Wallet {
      * touched; one still settling is waited for. `maxFee` caps the fees of every merge together,
      * `fees({ kind: 'consolidate' }).fee`. */
     consolidate(opts) {
-        return this.#exclusive(async () => {
+        return this.#seeded(async () => {
             if (!this.#ctx.network.mergeProver)
                 fail('invalid', 'this network has no merge prover');
             const to = { kind: 'self' };
@@ -895,12 +1011,12 @@ export class Wallet {
     /** Withdraws `amount` publicly to `to`, as zERC20 or with `unwrap` the underlying asset itself, so `to` needs no gas
      * to unwrap. One JoinSplit, as `send`, and as there `to` gets all of `amount` and `maxFee` caps what is paid on top
      * (`fees({ kind: 'withdraw' }).fee`). */
-    withdraw(opts) {
-        return this.#exclusive(async () => {
-            if (!isAddress(opts.to))
-                fail('invalid', `${String(opts.to)} is not an address`);
-            if (opts.amount <= 0n)
-                fail('invalid', 'the amount must be positive');
+    async withdraw(opts) {
+        if (!isAddress(opts.to))
+            fail('invalid', `${String(opts.to)} is not an address`);
+        if (opts.amount <= 0n)
+            fail('invalid', 'the amount must be positive');
+        return this.#seeded(async () => {
             const to = { kind: 'public', address: opts.to, unwrap: opts.unwrap };
             return this.#newPayment('withdraw', opts.token, opts.amount, { to, maxFee: opts.maxFee, step: null, paid: 0n });
         });
@@ -920,16 +1036,24 @@ export class Wallet {
         return this.#operation(op);
     }
 }
+/** Each chain of `network`, with its servers. */
+const chainsOf = (network) => network.chains.map((config) => ({
+    config,
+    chain: new Chain(config),
+    indexer: new Indexer(config.indexer),
+    asp: new Asp(config.asp),
+}));
 /** Holds `address`'s wallet until the returned function is called: two tabs on one wallet would each overwrite the
- * other's state and spend the same notes. Nothing where there are no Web Locks. */
-export async function lockWallet(address) {
+ * other's state and spend the same notes. A wallet that watches it (`view`) is held apart, as its state is its own.
+ * Nothing where there are no Web Locks. */
+export async function lockWallet(address, kind = 'wallet') {
     const locks = globalThis.navigator?.locks;
     if (!locks)
         return () => { };
     let release = () => { };
     const held = new Promise((r) => (release = r));
     const got = await new Promise((resolve) => {
-        void locks.request(`zerc20-wallet:${address.toLowerCase()}`, { ifAvailable: true }, (lock) => {
+        void locks.request(`zerc20-${kind}:${address.toLowerCase()}`, { ifAvailable: true }, (lock) => {
             resolve(lock !== null);
             return lock ? held : undefined;
         });