@zerc20/wallet-sdk 0.3.0 → 0.5.0

package/src/spend.ts

@@ -26,6 +26,7 @@ import { core } from './core.js';
 import { fail } from './errors.js';
 import { prove } from './prove.js';
 import { scan } from './scan.js';
+import type { Indexer } from './servers.js';
 import {
   type Relayed,
   RelayUnknown,
@@ -74,8 +75,10 @@ export interface Step {
   request?: object;
   /** Reverts with no sign of it on chain: proved again with the same outputs a few times, then failed. */
   attempts: number;
-  /** Once relayed: the indexer's nullifier count just after. Final nullifiers past it, and the input's still not among
-   * them, means a reorg dropped the transaction. */
+  /** Once relayed: the block the relayer saw it mined in. */
+  relayedBlock?: number;
+  /** The indexer's nullifier count once it is past that block, or just after a relay that found it landed already.
+   * Final nullifiers past it, and the input's still not among them, means a reorg dropped the transaction. */
   relayedAt?: number;
 }
 
@@ -100,6 +103,8 @@ export interface MergeStep {
   /** Refused by the prover, or reverting with no sign of it on chain: built again with the same output a few times,
    * then failed. */
   attempts: number;
+  /** As a JoinSplit's. */
+  relayedBlock?: number;
   relayedAt?: number;
 }
 
@@ -249,14 +254,20 @@ export function payWith(all: Coin[], need: bigint, fee: bigint, onTheWay: boolea
   return fail('insufficient-funds', `${need} is more than the balance`);
 }
 
-/** The smallest public withdrawal that still pays `net` after the protocol's cut. */
+/** The smallest public withdrawal that still pays `net` after the protocol's cut. The cut is a rate of the whole
+ * withdrawal, rounded down, and the rate read off one withdrawal (`fee / gross`) is at most its tier's: the smallest
+ * gross that pays `net` at that rate is never more than the answer within the tier, so a read or two settles it.
+ * ponytail: where a lower tier's bound lies between two reads, that bound may already pay `net`, a little less than
+ * the gross this returns; a getter for the schedule's tiers would find it. */
 export async function grossed(ctx: Ctx, chainId: bigint, tokenId: number, net: bigint): Promise<bigint> {
   const chain = chainCtx(ctx, chainId).chain;
   let gross = net;
-  for (let i = 0; i < 8; i++) {
+  // each read moves on by a unit at least, and a few settle each tier a withdrawal crosses
+  for (let i = 0; i < 64; i++) {
     const paid = gross - (await chain.withdrawFee(tokenId, gross));
     if (paid >= net) return gross;
-    gross += net - paid;
+    if (paid <= 0n) break;
+    gross = ((net - 1n) * gross) / paid + 1n;
   }
   return fail('unavailable', 'the withdrawal fee schedule does not settle');
 }
@@ -276,10 +287,16 @@ export async function withdrawalOf(
   return { withdrawn, protocol: withdrawn - net };
 }
 
+/** The rate, in basis points, of a protocol's `cut` out of a withdrawal of `gross`. The cut is rounded down, so this is
+ * exact once `gross` is 10,000 base units or more. */
+export const bpsOf = (cut: bigint, gross: bigint): number =>
+  gross === 0n ? 0 : Number((cut * 10_000n + gross - 1n) / gross);
+
 /** The most a payment out of `all` pays its recipient, the relayer's `fee` and the protocol's cut on top
  * (`withdrawalOf`): a withdrawal of what the relayer leaves, less the cut on it, or a private payment of what the
  * relayer's grossed fee leaves. Coins one JoinSplit cannot spend together (`pick`) are merged first, each merge
- * paying the relayer's grossed fee, as a consolidation's quote does. */
+ * paying the relayer's grossed fee, as a consolidation's quote does. `fee` is all the fees take of `all`; where they
+ * take it all, what they would be with nothing left to pay. */
 export async function maxPayment(
   ctx: Ctx,
   chainId: bigint,
@@ -287,13 +304,16 @@ export async function maxPayment(
   isPublic: boolean,
   all: Coin[],
   fee: bigint,
-): Promise<bigint> {
+): Promise<{ amount: bigint; fee: bigint; merges: number }> {
   const whole = all.length < 2 || (all.length === 2 && all.some((c) => c.kind === 'note'));
-  const merges = whole ? 0n : BigInt(roundsToMerge(all)) * (await grossed(ctx, chainId, tokenId, fee));
-  const total = all.reduce((s, c) => s + c.value, 0n) - merges;
-  const left = total - (isPublic ? fee : await grossed(ctx, chainId, tokenId, fee));
-  if (left <= 0n) return 0n;
-  return isPublic ? left - (await chainCtx(ctx, chainId).chain.withdrawFee(tokenId, left)) : left;
+  const merges = whole ? 0 : roundsToMerge(all);
+  const gross = !isPublic || merges > 0 ? await grossed(ctx, chainId, tokenId, fee) : fee;
+  const fees = BigInt(merges) * gross + (isPublic ? fee : gross);
+  const total = all.reduce((s, c) => s + c.value, 0n);
+  const left = total - fees;
+  if (left <= 0n) return { amount: 0n, fee: fees, merges };
+  const amount = isPublic ? left - (await chainCtx(ctx, chainId).chain.withdrawFee(tokenId, left)) : left;
+  return { amount, fee: total - amount, merges };
 }
 
 /** Plans the next step of `op`: a payment's only JoinSplit (or throws why there is none), or a consolidation's next
@@ -643,12 +663,21 @@ async function inputSpent(ctx: Ctx, op: SpendOperation, step: { inputs: Coin[] }
   return hits.length > 0;
 }
 
-/** Where a JoinSplit relayed when the indexer had `relayedAt` nullifiers stands, by its first input `f` as sync last
- * saw it: spent, or the final nullifiers passed it without its own (a reorg dropped it, or the relayer never sent it),
- * or neither yet. */
-export function relayedState(f: Position | undefined, relayedAt: number): 'landed' | 'dropped' | 'waiting' {
+/** Where a relayed JoinSplit stands, by its first input `f` as sync last saw it and `relayedAt`, a nullifier count past
+ * its own (`undefined` while not known): spent, or the final nullifiers passed that count without its own (a reorg
+ * dropped it, or the relayer never sent it), or neither yet. */
+export function relayedState(f: Position | undefined, relayedAt: number | undefined): 'landed' | 'dropped' | 'waiting' {
   if (f?.spent) return 'landed';
-  return f?.nullifier && f.nullifier.scannedTo >= relayedAt ? 'dropped' : 'waiting';
+  return f?.nullifier && relayedAt !== undefined && f.nullifier.scannedTo >= relayedAt ? 'dropped' : 'waiting';
+}
+
+/** The indexer's nullifier count once it is past `block`, so past the nullifiers of a transaction mined there unless a
+ * reorg moved them; `undefined` until then. The relayer answers once the block is mined, which may be before the
+ * indexer has read it. */
+export async function nullifiersPast(indexer: Pick<Indexer, 'status'>, block: number): Promise<number | undefined> {
+  if ((await indexer.status()).cursor < block) return undefined;
+  // a status reads its counts before its cursor, so the count comes from the next one
+  return (await indexer.status()).nullifiers;
 }
 
 /** Whether `op`'s payment or withdrawal is on chain: done, or relayed, which the relayer answers once it is mined. Until
@@ -775,17 +804,20 @@ export async function advanceSpend(ctx: Ctx, op: SpendOperation): Promise<void>
           await ctx.save();
           return;
         }
-        // an earlier relay of it landed, one whose answer was lost
+        // an earlier relay of it landed, one whose answer was lost, and the indexer counts its nullifier already
+        step.relayedAt = (await c.indexer.status()).nullifiers;
       } else {
         placeChange(ctx, op, step.outputs[1].salt, result.noteIndex2);
         data.txHashes = [...(data.txHashes ?? []), result.txHash];
+        step.relayedBlock = result.block;
+        delete step.relayedAt;
       }
-      step.relayedAt = (await c.indexer.status()).nullifiers;
       step.stage = 'relayed';
       await ctx.save();
     }
     if (step.stage === 'relayed') {
-      const now = relayedState(positionOf(ctx, op.chainId, step.inputs[0].index), step.relayedAt!);
+      step.relayedAt ??= await nullifiersPast(c.indexer, step.relayedBlock!);
+      const now = relayedState(positionOf(ctx, op.chainId, step.inputs[0].index), step.relayedAt);
       if (now === 'dropped') {
         // relay it again next sync; if it did land after all, that reverts and finds it
         step.stage = 'attested';
@@ -888,16 +920,19 @@ async function advanceMerge(ctx: Ctx, op: SpendOperation, step: MergeStep): Prom
     if ('reverted' in result) {
       // stale roots, most likely: built again with the same output, next sync
       if (!(await inputSpent(ctx, op, step))) return again(result.reverted);
-      // an earlier relay of it landed, one whose answer was lost
+      // an earlier relay of it landed, one whose answer was lost, and the indexer counts its nullifiers already
+      step.relayedAt = (await c.indexer.status()).nullifiers;
     } else {
       placeChange(ctx, op, step.output.salt, result.noteIndex);
       data.txHashes = [...(data.txHashes ?? []), result.txHash];
+      step.relayedBlock = result.block;
+      delete step.relayedAt;
     }
-    step.relayedAt = (await c.indexer.status()).nullifiers;
     step.stage = 'relayed';
     await ctx.save();
   }
-  const now = relayedState(positionOf(ctx, op.chainId, step.inputs[0].index), step.relayedAt!);
+  step.relayedAt ??= await nullifiersPast(c.indexer, step.relayedBlock!);
+  const now = relayedState(positionOf(ctx, op.chainId, step.inputs[0].index), step.relayedAt);
   if (now === 'dropped') {
     // relay it again next sync; if it did land after all, that reverts and finds it
     step.stage = 'proved';

package/src/state.ts

@@ -86,6 +86,10 @@ export interface DepositRecord {
   /** Chosen by a payer, who told it in storage (a burn), as claimed: its salt is the payer's, with no index
    * (`burnIndex` -1), and it is never handed out. */
   payer?: Hex;
+  /** Recorded by another device of the wallet, or before a restore: taken as handed out, so never handed out here. A
+   * flag of its own rather than the token's `burnNext`, which would also pass the one this device recorded ahead and
+   * still holds: with two devices open, each would then record one more ahead each sync, without end. */
+  elsewhere?: true;
   /** The transfer's tag under each token. */
   watches: { tokenId: number; watch: Watch }[];
   found: (Position & {
@@ -114,9 +118,27 @@ export interface SentRecord extends Pick<
  * `unwritten` until storage holds it: every sync tries again. */
 export type ReceiptRecord = { chainId: bigint; tokenId: number; burnAddress: Hex; atMs: number; unwritten?: true } & (
   | { kind: 'returned'; index: number; recipient: Hex; amount: bigint; txHash: Hex }
-  | { kind: 'deposit-address'; depositAddress: Hex }
+  | {
+      kind: 'deposit-address';
+      depositAddress: Hex;
+      /** From the relayer's answer, or as storage told them. Absent where storage's record does not tell them, and then
+       * only the relayer flushes it. */
+      args?: DepositAddressArgs;
+    }
 );
 
+/** What a deposit address was registered with besides its token and burn address: with those, all a flush of it takes.
+ * A wallet's refunds go where a signer of its own signs for, so its refund address is zero. */
+export interface DepositAddressArgs {
+  fee: bigint;
+  feeRecipient: Hex;
+  refundSigner: Hex;
+  referrer: Hex;
+  referralBps: number;
+}
+
+export type DepositAddressReceipt = Extract<ReceiptRecord, { kind: 'deposit-address' }>;
+
 /** A sample of the indexer's final counts, to bound where a note announced at some time can be. */
 export interface Sample {
   atMs: number;
@@ -155,6 +177,8 @@ export interface DepositOperation extends OperationBase {
     burnAddress: Hex;
     /** Whose burn address it is, when not this wallet's (`deposit({ to })`). */
     to?: Hex;
+    /** The receive code it paid, when `to` was one. */
+    code?: string;
     /** Its transaction, once sent. */
     txHash?: Hex;
   };

package/src/sync.ts

@@ -4,6 +4,7 @@
 import {
   type Deposit,
   type LaneRecord,
+  type DepositArgs,
   type NewRecord,
   type Note,
   type OwnReceipt,
@@ -18,11 +19,11 @@ import {
 } from '@zerc20/storage-sdk';
 import { type Hex, bytesToHex, hexToBytes, numberToHex, parseAbiItem } from 'viem';
 import type { Chain, Token } from './chain.js';
-import { type ChainCtx, type Ctx, chainCtx, chainState, owner } from './context.js';
+import { type ChainCtx, type Ctx, chainCtx, chainState, owner, refundSigner } from './context.js';
 import { burnAddress, core } from './core.js';
 import { type Hit, type Watch, scan } from './scan.js';
 import { type Asp, type AspStatus, type Indexer, PAGE } from './servers.js';
-import type { DepositRecord, NoteReceipt, NoteRecord, Position, Sample } from './state.js';
+import type { DepositAddressArgs, DepositRecord, NoteReceipt, NoteRecord, Position, Sample } from './state.js';
 
 /** The ledger's log of each commitment, found by its index (`contracts/src/CommitmentLedger.sol`). */
 const committedEvent = parseAbiItem('event Committed(uint64 indexed index, uint256[4] fields)');
@@ -95,7 +96,12 @@ async function writeReceipts(ctx: Ctx, tokens: Map<bigint, number[]>): Promise<v
             amount: hexToBytes(numberToHex(r.amount, { size: 32 })),
             txHash: hexToBytes(r.txHash),
           }
-        : { ...head, kind: r.kind, depositAddress: hexToBytes(r.depositAddress) };
+        : {
+            ...head,
+            kind: r.kind,
+            depositAddress: hexToBytes(r.depositAddress),
+            ...(r.args && { args: depositArgsBytes(r.args) }),
+          };
     takeRefresh(
       ctx,
       await commit(ctx.storage, ctx.view, storageState(ctx), (s) => planReceipt(ctx.view, s, receipt)),
@@ -106,6 +112,24 @@ async function writeReceipts(ctx: Ctx, tokens: Map<bigint, number[]>): Promise<v
   }
 }
 
+/** A deposit address's arguments as the wallet keeps them, from storage's. */
+const depositArgs = (a: DepositArgs): DepositAddressArgs => ({
+  fee: big(a.fee),
+  feeRecipient: bytesToHex(a.feeRecipient),
+  refundSigner: bytesToHex(a.refundSigner),
+  referrer: bytesToHex(a.referrer),
+  referralBps: a.referralBps,
+});
+
+/** And storage's, from the wallet's. */
+const depositArgsBytes = (a: DepositAddressArgs): DepositArgs => ({
+  fee: hexToBytes(numberToHex(a.fee, { size: 32 })),
+  feeRecipient: hexToBytes(a.feeRecipient),
+  refundSigner: hexToBytes(a.refundSigner),
+  referrer: hexToBytes(a.referrer),
+  referralBps: a.referralBps,
+});
+
 /** A storage receipt as the wallet keeps it. */
 export const noteReceipt = (r: Receipt): NoteReceipt => ({
   kind: r.kind,
@@ -182,16 +206,24 @@ function takeSent(ctx: Ctx, d: Deposit, to: Uint8Array, tokens: Map<bigint, numb
 function takeReceipt(ctx: Ctx, r: OwnReceipt & { atNs: bigint }): void {
   const burnAddress = bytesToHex(r.burnAddress);
   const atMs = Number(r.atNs / 1_000_000n);
+  // a return is told apart by its deposit, a deposit address by itself: one burn address can have more than one, each
+  // registered with arguments of its own
   const same = ctx.state.receipts.find(
     (x) =>
       x.chainId === r.chainId &&
-      x.kind === r.kind &&
       x.burnAddress === burnAddress &&
-      (x.kind !== 'returned' || (r.kind === 'returned' && x.index === r.index)),
+      (x.kind === 'returned' && r.kind === 'returned'
+        ? x.index === r.index
+        : x.kind === 'deposit-address' &&
+          r.kind === 'deposit-address' &&
+          x.depositAddress.toLowerCase() === bytesToHex(r.depositAddress)),
   );
+  // what its address was registered with, where the record tells it
+  const args = r.kind === 'deposit-address' && r.args && { args: depositArgs(r.args) };
   if (same) {
     delete same.unwritten;
     same.atMs = atMs;
+    Object.assign(same, args);
     return;
   }
   const head = { chainId: r.chainId, tokenId: r.tokenId, burnAddress, atMs };
@@ -205,7 +237,7 @@ function takeReceipt(ctx: Ctx, r: OwnReceipt & { atNs: bigint }): void {
           amount: big(r.amount),
           txHash: bytesToHex(r.txHash),
         }
-      : { ...head, kind: r.kind, depositAddress: bytesToHex(r.depositAddress) },
+      : { ...head, kind: r.kind, depositAddress: bytesToHex(r.depositAddress), ...args },
   );
 }
 
@@ -255,10 +287,6 @@ function takeBurnBlock(
     const salt = hex32(bytes);
     const address = core.burnAddressOf(b.chainId, publicKey, salt) as Hex | undefined;
     if (!address || ctx.state.deposits.some((d) => d.chainId === b.chainId && d.salt === salt)) return;
-    if (!pos) {
-      const next = chainState(ctx, b.chainId).burnNext;
-      next[b.tokenId] = Math.max(next[b.tokenId] ?? 0, b.first + i + 1);
-    }
     const watch = { key: numberToHex(core.transferTag(b.tokenId, address), { size: 4 }), from, scannedTo: from };
     const record: DepositRecord = {
       chainId: b.chainId,
@@ -272,6 +300,7 @@ function takeBurnBlock(
       found: [],
     };
     if (pos) record.managed = true;
+    else record.elsewhere = true;
     ctx.state.deposits.push(record);
   });
 }
@@ -281,7 +310,8 @@ export function unusedBurn(ctx: Ctx, chainId: bigint, tokenId: number): DepositR
   const next = chainState(ctx, chainId).burnNext[tokenId] ?? 0;
   let best: DepositRecord | undefined;
   for (const d of ctx.state.deposits) {
-    if (d.chainId !== chainId || d.tokenId !== tokenId || d.managed || d.payer || d.burnIndex < next) continue;
+    if (d.chainId !== chainId || d.tokenId !== tokenId || d.managed || d.payer || d.elsewhere || d.burnIndex < next)
+      continue;
     if (!best || d.burnIndex < best.burnIndex) best = d;
   }
   return best;
@@ -302,17 +332,18 @@ export const nextBurn = (ctx: Ctx, chainId: bigint, tokenId: number): number =>
   unusedBurn(ctx, chainId, tokenId)?.burnIndex ?? toRecord(ctx, chainId, tokenId);
 
 /** Records this wallet's next burn address of a token in storage (a burn block of one), then watches it. Every device
- * of the wallet, and a restore, then watches it too and never hands it out again. About 2^16 hashes; needs no seed. */
+ * of the wallet, and a restore, then watches it too and never hands it out again. About 2^16 hashes, `urgent` unless
+ * it is one made ahead; needs no seed. */
 export async function recordBurn(
   ctx: Ctx,
   chainId: bigint,
   tokenId: number,
   tokens: Map<bigint, number[]>,
-  signal?: AbortSignal,
+  opts: { signal?: AbortSignal; urgent?: boolean } = {},
 ): Promise<DepositRecord> {
   const index = toRecord(ctx, chainId, tokenId);
   const key = burnKey(ctx.view.seed);
-  const { salt, address } = await burnAddress(key, chainId, tokenId, index, owner(ctx)!.publicKey, signal);
+  const { salt, address } = await burnAddress(key, chainId, tokenId, index, owner(ctx)!.publicKey, opts);
   const { commitmentsFinal: from } = await chainCtx(ctx, chainId).indexer.status();
   const block = { chainId, tokenId, first: index, salts: [hexToBytes(salt)] };
   const result = await commit(ctx.storage, ctx.view, storageState(ctx), (s) => planBurnBlock(ctx.view, s, block));
@@ -350,7 +381,7 @@ export async function topUpBurns(ctx: Ctx, signal?: AbortSignal): Promise<void>
   let tokens: Map<bigint, number[]> | undefined;
   for (const { chainId, tokenId } of used.values()) {
     if (!unusedBurn(ctx, chainId, tokenId))
-      await recordBurn(ctx, chainId, tokenId, (tokens ??= await tokenIds(ctx)), signal);
+      await recordBurn(ctx, chainId, tokenId, (tokens ??= await tokenIds(ctx)), { signal, urgent: false });
   }
 }
 
@@ -394,12 +425,13 @@ function upsertNote(ctx: Ctx, a: NewRecord, note: Note, tokens: Map<bigint, numb
   });
 }
 
-/** Receive codes of each token whose keys are derived while the seed is held, to hand out while it is not. */
+/** Receive codes of each token whose keys are derived while the seed is held, to hand out while it is not, and as many
+ * deposit addresses' refund signers. */
 export const CODES_AHEAD = 4;
 
 /** With the seed held, each owner not derived yet: the wallet's own, each of its burn addresses' (a receive code each),
- * the next `CODES_AHEAD` codes' of each of `tokens`, and each note's key's; and the watch of each note that waited for
- * its key. */
+ * the next `CODES_AHEAD` codes' of each of `tokens` with their deposit addresses' refund signers, and each note's key's;
+ * and the watch of each note that waited for its key. Without it, the watch of each note whose key was derived before. */
 export function keyAll(ctx: Ctx, tokens: Token[]): void {
   owner(ctx);
   // ponytail: one derivation per own burn address as the wallet opens; keep owners in the saved state if wallets grow
@@ -409,14 +441,19 @@ export function keyAll(ctx: Ctx, tokens: Token[]): void {
   }
   for (const { chainId, tokenId } of tokens) {
     const next = nextBurn(ctx, chainId, tokenId);
-    for (let index = next; index < next + CODES_AHEAD; index++) owner(ctx, { chainId, tokenId, index });
+    for (let index = next; index < next + CODES_AHEAD; index++) {
+      owner(ctx, { chainId, tokenId, index });
+      refundSigner(ctx, { chainId, tokenId, index });
+    }
   }
   for (const n of ctx.state.notes) {
     if (n.keyIndex === undefined) continue;
     owner(ctx, { chainId: n.chainId, tokenId: n.tokenId, index: n.keyIndex });
     if (!n.unkeyed) continue;
     const from = commitmentsAt(chainState(ctx, n.chainId).samples, Number((n.atNs ?? 0n) / 1_000_000n) - DAY_MS);
-    Object.assign(n, watchFor(ctx, n.chainId, n.tokenId, n.value, n.salt, n.keyIndex, from));
+    const watched = watchFor(ctx, n.chainId, n.tokenId, n.value, n.salt, n.keyIndex, from);
+    if (!watched) continue; // still waits for the seed
+    Object.assign(n, watched);
     delete n.unkeyed;
   }
 }

package/src/viewKey.ts

@@ -0,0 +1,49 @@
+// A view key as text: what `Wallet.watch` follows an account with, spending nothing.
+
+import { bech32m } from '@scure/base';
+import type { ViewKey } from '@zerc20/storage-sdk';
+import { type Address, type Hex, bytesToHex, concat, getAddress, hexToBytes } from 'viem';
+import type { Owner } from './context.js';
+import { core } from './core.js';
+
+const PREFIX = 'zerc20view';
+
+/** `view` and the wallet's own `owner` as checksummed text (bech32m, `zerc20view1…`): `address(20) ‖ view seed(32) ‖
+ * auth key hash(32) ‖ nullifying key(32)`. The public key is left for the holder to make from the last two, so that a
+ * nullifying key that is not the account's makes a public key that is not either. */
+export function encodeViewKey(view: ViewKey, owner: Owner): string {
+  const bytes = concat([view.address, view.seed, hexToBytes(owner.authKeyHash), hexToBytes(owner.nullifyingKey)]);
+  return bech32m.encode(PREFIX, bech32m.toWords(bytes), false);
+}
+
+function bytesOf(text: string): Uint8Array | null {
+  try {
+    const { prefix, bytes } = bech32m.decodeToBytes(text.trim(), false);
+    return prefix === PREFIX && bytes.length === 116 ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The account `text` is a view key of, or `null` if it is not one: to tell a key apart before it is opened. */
+export function viewKeyAccount(text: string): Address | null {
+  const bytes = bytesOf(text);
+  return bytes && getAddress(bytesToHex(bytes.subarray(0, 20)));
+}
+
+/** The view key and owner `text` holds, or `null` for anything else. Needs `initCore`. */
+export function decodeViewKey(text: string): { view: ViewKey; owner: Owner } | null {
+  const bytes = bytesOf(text);
+  if (!bytes) return null;
+  const authKeyHash = bytesToHex(bytes.subarray(52, 84));
+  const nullifyingKey = bytesToHex(bytes.subarray(84));
+  try {
+    const publicKey = core.publicKey(authKeyHash, nullifyingKey) as Hex;
+    return {
+      view: { address: bytes.slice(0, 20), seed: bytes.slice(20, 52) },
+      owner: { authKeyHash, publicKey, nullifyingKey },
+    };
+  } catch {
+    return null; // a value that is not a field element
+  }
+}