@metamask/ramps-controller 20.2.0 → 20.3.0

package/dist/wallet-registration-machine.d.cts

@@ -0,0 +1,81 @@
+/**
+ * Pure, hand-rolled finite state machine for the MoonPay Iron self-hosted
+ * wallet registration signing step. It follows the FSM convention used
+ * elsewhere in `core` (no XState dependency): a single pure `transition`
+ * reducer plus a data-driven transition table.
+ *
+ * Side effects (server lookups, signing, POSTing) live in the interpreter that
+ * drives this machine; every effect result is fed back in as an event, so the
+ * machine itself stays deterministic and trivially testable.
+ */
+/** Every state in the signing step. */
+export type WalletRegistrationStatus = 'idle' | 'preparing' | 'awaitingUnlock' | 'signing' | 'submitting' | 'disambiguate409' | 'checkThenRetry' | 'lookupUnavailable' | 'registered' | 'alreadyRegistered' | 'registeredDisabled' | 'failedRetryable' | 'failedTerminal' | 'cancelled';
+/** Machine context carried across transitions. */
+export type WalletRegistrationContext = {
+    /** Number of sign attempts made so far (used for the retry ceiling). */
+    attempts: number;
+    /** Maximum number of sign attempts before a retryable failure is surfaced. */
+    maxAttempts: number;
+};
+export type WalletRegistrationState = {
+    status: WalletRegistrationStatus;
+    context: WalletRegistrationContext;
+};
+/** Events the interpreter dispatches into the machine. */
+export type WalletRegistrationEvent = {
+    type: 'START';
+} | {
+    type: 'WALLET_LOCKED';
+} | {
+    type: 'WALLET_UNLOCKED';
+} | {
+    type: 'LOOKUP_ACTIVE';
+} | {
+    type: 'LOOKUP_DISABLED';
+} | {
+    type: 'LOOKUP_ABSENT';
+} | {
+    type: 'LOOKUP_FAILED';
+} | {
+    type: 'SIGN_OK';
+} | {
+    type: 'SIGN_REJECTED';
+} | {
+    type: 'SIGN_FAILED';
+    retryable: boolean;
+} | {
+    type: 'SUBMIT_OK';
+} | {
+    type: 'SUBMIT_CONFLICT';
+} | {
+    type: 'SUBMIT_TRANSIENT';
+} | {
+    type: 'SUBMIT_VALIDATION';
+    utcRollover: boolean;
+} | {
+    type: 'SUBMIT_TERMINAL';
+} | {
+    type: 'SUBMIT_RATE_LIMITED';
+} | {
+    type: 'RETRY';
+} | {
+    type: 'CANCEL';
+};
+/**
+ * Creates the initial idle state.
+ *
+ * @param maxAttempts - Optional retry ceiling for sign attempts.
+ * @returns A fresh idle machine state.
+ */
+export declare function createInitialState(maxAttempts?: number): WalletRegistrationState;
+/**
+ * Pure transition reducer. Unhandled (state, event) pairs are no-ops, which is
+ * how the machine enforces "one in-flight operation" (a second `START` while
+ * busy is ignored) and how terminal states stay put.
+ *
+ * @param state - Current machine state.
+ * @param event - Event to apply.
+ * @returns The next state (or the same state for unhandled events).
+ */
+export declare function transition(state: WalletRegistrationState, event: WalletRegistrationEvent): WalletRegistrationState;
+//# sourceMappingURL=wallet-registration-machine.d.cts.map

package/dist/wallet-registration-machine.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-registration-machine.d.cts","sourceRoot":"","sources":["../src/wallet-registration-machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,uCAAuC;AACvC,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,WAAW,GACX,gBAAgB,GAChB,SAAS,GACT,YAAY,GACZ,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,YAAY,GACZ,mBAAmB,GACnB,oBAAoB,GACpB,iBAAiB,GACjB,gBAAgB,GAChB,WAAW,CAAC;AAEhB,kDAAkD;AAClD,MAAM,MAAM,yBAAyB,GAAG;IACtC,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,EAAE,yBAAyB,CAAC;CACpC,CAAC;AAEF,0DAA0D;AAC1D,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAWvB;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,GAAE,MAA6B,GACzC,uBAAuB,CAEzB;AA4HD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,uBAAuB,EAC9B,KAAK,EAAE,uBAAuB,GAC7B,uBAAuB,CAGzB"}

package/dist/wallet-registration-machine.d.mts

@@ -0,0 +1,81 @@
+/**
+ * Pure, hand-rolled finite state machine for the MoonPay Iron self-hosted
+ * wallet registration signing step. It follows the FSM convention used
+ * elsewhere in `core` (no XState dependency): a single pure `transition`
+ * reducer plus a data-driven transition table.
+ *
+ * Side effects (server lookups, signing, POSTing) live in the interpreter that
+ * drives this machine; every effect result is fed back in as an event, so the
+ * machine itself stays deterministic and trivially testable.
+ */
+/** Every state in the signing step. */
+export type WalletRegistrationStatus = 'idle' | 'preparing' | 'awaitingUnlock' | 'signing' | 'submitting' | 'disambiguate409' | 'checkThenRetry' | 'lookupUnavailable' | 'registered' | 'alreadyRegistered' | 'registeredDisabled' | 'failedRetryable' | 'failedTerminal' | 'cancelled';
+/** Machine context carried across transitions. */
+export type WalletRegistrationContext = {
+    /** Number of sign attempts made so far (used for the retry ceiling). */
+    attempts: number;
+    /** Maximum number of sign attempts before a retryable failure is surfaced. */
+    maxAttempts: number;
+};
+export type WalletRegistrationState = {
+    status: WalletRegistrationStatus;
+    context: WalletRegistrationContext;
+};
+/** Events the interpreter dispatches into the machine. */
+export type WalletRegistrationEvent = {
+    type: 'START';
+} | {
+    type: 'WALLET_LOCKED';
+} | {
+    type: 'WALLET_UNLOCKED';
+} | {
+    type: 'LOOKUP_ACTIVE';
+} | {
+    type: 'LOOKUP_DISABLED';
+} | {
+    type: 'LOOKUP_ABSENT';
+} | {
+    type: 'LOOKUP_FAILED';
+} | {
+    type: 'SIGN_OK';
+} | {
+    type: 'SIGN_REJECTED';
+} | {
+    type: 'SIGN_FAILED';
+    retryable: boolean;
+} | {
+    type: 'SUBMIT_OK';
+} | {
+    type: 'SUBMIT_CONFLICT';
+} | {
+    type: 'SUBMIT_TRANSIENT';
+} | {
+    type: 'SUBMIT_VALIDATION';
+    utcRollover: boolean;
+} | {
+    type: 'SUBMIT_TERMINAL';
+} | {
+    type: 'SUBMIT_RATE_LIMITED';
+} | {
+    type: 'RETRY';
+} | {
+    type: 'CANCEL';
+};
+/**
+ * Creates the initial idle state.
+ *
+ * @param maxAttempts - Optional retry ceiling for sign attempts.
+ * @returns A fresh idle machine state.
+ */
+export declare function createInitialState(maxAttempts?: number): WalletRegistrationState;
+/**
+ * Pure transition reducer. Unhandled (state, event) pairs are no-ops, which is
+ * how the machine enforces "one in-flight operation" (a second `START` while
+ * busy is ignored) and how terminal states stay put.
+ *
+ * @param state - Current machine state.
+ * @param event - Event to apply.
+ * @returns The next state (or the same state for unhandled events).
+ */
+export declare function transition(state: WalletRegistrationState, event: WalletRegistrationEvent): WalletRegistrationState;
+//# sourceMappingURL=wallet-registration-machine.d.mts.map

package/dist/wallet-registration-machine.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-registration-machine.d.mts","sourceRoot":"","sources":["../src/wallet-registration-machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,uCAAuC;AACvC,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,WAAW,GACX,gBAAgB,GAChB,SAAS,GACT,YAAY,GACZ,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,YAAY,GACZ,mBAAmB,GACnB,oBAAoB,GACpB,iBAAiB,GACjB,gBAAgB,GAChB,WAAW,CAAC;AAEhB,kDAAkD;AAClD,MAAM,MAAM,yBAAyB,GAAG;IACtC,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,EAAE,yBAAyB,CAAC;CACpC,CAAC;AAEF,0DAA0D;AAC1D,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC3B;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAWvB;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,GAAE,MAA6B,GACzC,uBAAuB,CAEzB;AA4HD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,uBAAuB,EAC9B,KAAK,EAAE,uBAAuB,GAC7B,uBAAuB,CAGzB"}

package/dist/wallet-registration-machine.mjs

@@ -0,0 +1,139 @@
+/**
+ * Pure, hand-rolled finite state machine for the MoonPay Iron self-hosted
+ * wallet registration signing step. It follows the FSM convention used
+ * elsewhere in `core` (no XState dependency): a single pure `transition`
+ * reducer plus a data-driven transition table.
+ *
+ * Side effects (server lookups, signing, POSTing) live in the interpreter that
+ * drives this machine; every effect result is fed back in as an event, so the
+ * machine itself stays deterministic and trivially testable.
+ */
+const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * Creates the initial idle state.
+ *
+ * @param maxAttempts - Optional retry ceiling for sign attempts.
+ * @returns A fresh idle machine state.
+ */
+export function createInitialState(maxAttempts = DEFAULT_MAX_ATTEMPTS) {
+    return { status: 'idle', context: { attempts: 0, maxAttempts } };
+}
+/**
+ * Builds a handler that moves to a status while preserving context.
+ *
+ * @param status - Target status.
+ * @returns A handler transitioning to `status`.
+ */
+function keep(status) {
+    return (state) => ({ status, context: state.context });
+}
+/**
+ * Builds a handler that moves to a status and resets the retry context. Used
+ * when the user (or app resume) starts a fresh attempt from scratch.
+ *
+ * @param status - Target status.
+ * @returns A handler transitioning to `status` with reset context.
+ */
+function reset(status) {
+    return (state) => ({
+        status,
+        context: { ...state.context, attempts: 0 },
+    });
+}
+/**
+ * Moves to `signing` and counts this as a new sign attempt.
+ *
+ * @param state - Current state.
+ * @returns The `signing` state with an incremented attempt count.
+ */
+const toSigning = (state) => ({
+    status: 'signing',
+    context: { ...state.context, attempts: state.context.attempts + 1 },
+});
+const toPreparing = reset('preparing');
+const toAlreadyRegistered = keep('alreadyRegistered');
+const toRegisteredDisabled = keep('registeredDisabled');
+const toLookupUnavailable = keep('lookupUnavailable');
+const toCancelled = keep('cancelled');
+const signFailed = (state, event) => {
+    const { retryable } = event;
+    return retryable
+        ? keep('failedRetryable')(state, event)
+        : keep('failedTerminal')(state, event);
+};
+const submitValidation = (state, event) => {
+    const { utcRollover } = event;
+    return utcRollover && state.context.attempts < state.context.maxAttempts
+        ? toSigning(state, event)
+        : keep('failedTerminal')(state, event);
+};
+const checkThenRetryAbsent = (state, event) => state.context.attempts < state.context.maxAttempts
+    ? toSigning(state, event)
+    : keep('failedRetryable')(state, event);
+const TABLE = {
+    idle: {
+        START: toPreparing,
+    },
+    preparing: {
+        LOOKUP_ACTIVE: toAlreadyRegistered,
+        LOOKUP_DISABLED: toRegisteredDisabled,
+        LOOKUP_ABSENT: toSigning,
+        LOOKUP_FAILED: toLookupUnavailable,
+    },
+    awaitingUnlock: {
+        WALLET_UNLOCKED: keep('signing'),
+    },
+    signing: {
+        SIGN_OK: keep('submitting'),
+        SIGN_REJECTED: toCancelled,
+        SIGN_FAILED: signFailed,
+        WALLET_LOCKED: keep('awaitingUnlock'),
+        CANCEL: toCancelled,
+    },
+    submitting: {
+        SUBMIT_OK: keep('registered'),
+        SUBMIT_CONFLICT: keep('disambiguate409'),
+        SUBMIT_TRANSIENT: keep('checkThenRetry'),
+        SUBMIT_VALIDATION: submitValidation,
+        SUBMIT_TERMINAL: keep('failedTerminal'),
+        SUBMIT_RATE_LIMITED: keep('failedRetryable'),
+        CANCEL: toCancelled,
+    },
+    disambiguate409: {
+        LOOKUP_ACTIVE: toAlreadyRegistered,
+        LOOKUP_DISABLED: toRegisteredDisabled,
+        LOOKUP_ABSENT: keep('failedRetryable'),
+        LOOKUP_FAILED: toLookupUnavailable,
+        CANCEL: toCancelled,
+    },
+    checkThenRetry: {
+        LOOKUP_ACTIVE: toAlreadyRegistered,
+        LOOKUP_DISABLED: toRegisteredDisabled,
+        LOOKUP_ABSENT: checkThenRetryAbsent,
+        LOOKUP_FAILED: toLookupUnavailable,
+        CANCEL: toCancelled,
+    },
+    failedRetryable: {
+        RETRY: toPreparing,
+    },
+    lookupUnavailable: {
+        RETRY: toPreparing,
+    },
+    cancelled: {
+        RETRY: toPreparing,
+    },
+};
+/**
+ * Pure transition reducer. Unhandled (state, event) pairs are no-ops, which is
+ * how the machine enforces "one in-flight operation" (a second `START` while
+ * busy is ignored) and how terminal states stay put.
+ *
+ * @param state - Current machine state.
+ * @param event - Event to apply.
+ * @returns The next state (or the same state for unhandled events).
+ */
+export function transition(state, event) {
+    const handler = TABLE[state.status]?.[event.type];
+    return handler ? handler(state, event) : state;
+}
+//# sourceMappingURL=wallet-registration-machine.mjs.map

package/dist/wallet-registration-machine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-registration-machine.mjs","sourceRoot":"","sources":["../src/wallet-registration-machine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure, hand-rolled finite state machine for the MoonPay Iron self-hosted\n * wallet registration signing step. It follows the FSM convention used\n * elsewhere in `core` (no XState dependency): a single pure `transition`\n * reducer plus a data-driven transition table.\n *\n * Side effects (server lookups, signing, POSTing) live in the interpreter that\n * drives this machine; every effect result is fed back in as an event, so the\n * machine itself stays deterministic and trivially testable.\n */\n\n/** Every state in the signing step. */\nexport type WalletRegistrationStatus =\n  | 'idle'\n  | 'preparing'\n  | 'awaitingUnlock'\n  | 'signing'\n  | 'submitting'\n  | 'disambiguate409'\n  | 'checkThenRetry'\n  | 'lookupUnavailable'\n  | 'registered'\n  | 'alreadyRegistered'\n  | 'registeredDisabled'\n  | 'failedRetryable'\n  | 'failedTerminal'\n  | 'cancelled';\n\n/** Machine context carried across transitions. */\nexport type WalletRegistrationContext = {\n  /** Number of sign attempts made so far (used for the retry ceiling). */\n  attempts: number;\n  /** Maximum number of sign attempts before a retryable failure is surfaced. */\n  maxAttempts: number;\n};\n\nexport type WalletRegistrationState = {\n  status: WalletRegistrationStatus;\n  context: WalletRegistrationContext;\n};\n\n/** Events the interpreter dispatches into the machine. */\nexport type WalletRegistrationEvent =\n  | { type: 'START' }\n  | { type: 'WALLET_LOCKED' }\n  | { type: 'WALLET_UNLOCKED' }\n  | { type: 'LOOKUP_ACTIVE' }\n  | { type: 'LOOKUP_DISABLED' }\n  | { type: 'LOOKUP_ABSENT' }\n  | { type: 'LOOKUP_FAILED' }\n  | { type: 'SIGN_OK' }\n  | { type: 'SIGN_REJECTED' }\n  | { type: 'SIGN_FAILED'; retryable: boolean }\n  | { type: 'SUBMIT_OK' }\n  | { type: 'SUBMIT_CONFLICT' }\n  | { type: 'SUBMIT_TRANSIENT' }\n  | { type: 'SUBMIT_VALIDATION'; utcRollover: boolean }\n  | { type: 'SUBMIT_TERMINAL' }\n  | { type: 'SUBMIT_RATE_LIMITED' }\n  | { type: 'RETRY' }\n  | { type: 'CANCEL' };\n\ntype EventType = WalletRegistrationEvent['type'];\n\ntype Handler = (\n  state: WalletRegistrationState,\n  event: WalletRegistrationEvent,\n) => WalletRegistrationState;\n\nconst DEFAULT_MAX_ATTEMPTS = 3;\n\n/**\n * Creates the initial idle state.\n *\n * @param maxAttempts - Optional retry ceiling for sign attempts.\n * @returns A fresh idle machine state.\n */\nexport function createInitialState(\n  maxAttempts: number = DEFAULT_MAX_ATTEMPTS,\n): WalletRegistrationState {\n  return { status: 'idle', context: { attempts: 0, maxAttempts } };\n}\n\n/**\n * Builds a handler that moves to a status while preserving context.\n *\n * @param status - Target status.\n * @returns A handler transitioning to `status`.\n */\nfunction keep(status: WalletRegistrationStatus): Handler {\n  return (state) => ({ status, context: state.context });\n}\n\n/**\n * Builds a handler that moves to a status and resets the retry context. Used\n * when the user (or app resume) starts a fresh attempt from scratch.\n *\n * @param status - Target status.\n * @returns A handler transitioning to `status` with reset context.\n */\nfunction reset(status: WalletRegistrationStatus): Handler {\n  return (state) => ({\n    status,\n    context: { ...state.context, attempts: 0 },\n  });\n}\n\n/**\n * Moves to `signing` and counts this as a new sign attempt.\n *\n * @param state - Current state.\n * @returns The `signing` state with an incremented attempt count.\n */\nconst toSigning: Handler = (state) => ({\n  status: 'signing',\n  context: { ...state.context, attempts: state.context.attempts + 1 },\n});\n\nconst toPreparing = reset('preparing');\nconst toAlreadyRegistered = keep('alreadyRegistered');\nconst toRegisteredDisabled = keep('registeredDisabled');\nconst toLookupUnavailable = keep('lookupUnavailable');\nconst toCancelled = keep('cancelled');\n\nconst signFailed: Handler = (state, event) => {\n  const { retryable } = event as Extract<\n    WalletRegistrationEvent,\n    { type: 'SIGN_FAILED' }\n  >;\n  return retryable\n    ? keep('failedRetryable')(state, event)\n    : keep('failedTerminal')(state, event);\n};\n\nconst submitValidation: Handler = (state, event) => {\n  const { utcRollover } = event as Extract<\n    WalletRegistrationEvent,\n    { type: 'SUBMIT_VALIDATION' }\n  >;\n  return utcRollover && state.context.attempts < state.context.maxAttempts\n    ? toSigning(state, event)\n    : keep('failedTerminal')(state, event);\n};\n\nconst checkThenRetryAbsent: Handler = (state, event) =>\n  state.context.attempts < state.context.maxAttempts\n    ? toSigning(state, event)\n    : keep('failedRetryable')(state, event);\n\nconst TABLE: Partial<\n  Record<WalletRegistrationStatus, Partial<Record<EventType, Handler>>>\n> = {\n  idle: {\n    START: toPreparing,\n  },\n  preparing: {\n    LOOKUP_ACTIVE: toAlreadyRegistered,\n    LOOKUP_DISABLED: toRegisteredDisabled,\n    LOOKUP_ABSENT: toSigning,\n    LOOKUP_FAILED: toLookupUnavailable,\n  },\n  awaitingUnlock: {\n    WALLET_UNLOCKED: keep('signing'),\n  },\n  signing: {\n    SIGN_OK: keep('submitting'),\n    SIGN_REJECTED: toCancelled,\n    SIGN_FAILED: signFailed,\n    WALLET_LOCKED: keep('awaitingUnlock'),\n    CANCEL: toCancelled,\n  },\n  submitting: {\n    SUBMIT_OK: keep('registered'),\n    SUBMIT_CONFLICT: keep('disambiguate409'),\n    SUBMIT_TRANSIENT: keep('checkThenRetry'),\n    SUBMIT_VALIDATION: submitValidation,\n    SUBMIT_TERMINAL: keep('failedTerminal'),\n    SUBMIT_RATE_LIMITED: keep('failedRetryable'),\n    CANCEL: toCancelled,\n  },\n  disambiguate409: {\n    LOOKUP_ACTIVE: toAlreadyRegistered,\n    LOOKUP_DISABLED: toRegisteredDisabled,\n    LOOKUP_ABSENT: keep('failedRetryable'),\n    LOOKUP_FAILED: toLookupUnavailable,\n    CANCEL: toCancelled,\n  },\n  checkThenRetry: {\n    LOOKUP_ACTIVE: toAlreadyRegistered,\n    LOOKUP_DISABLED: toRegisteredDisabled,\n    LOOKUP_ABSENT: checkThenRetryAbsent,\n    LOOKUP_FAILED: toLookupUnavailable,\n    CANCEL: toCancelled,\n  },\n  failedRetryable: {\n    RETRY: toPreparing,\n  },\n  lookupUnavailable: {\n    RETRY: toPreparing,\n  },\n  cancelled: {\n    RETRY: toPreparing,\n  },\n};\n\n/**\n * Pure transition reducer. Unhandled (state, event) pairs are no-ops, which is\n * how the machine enforces \"one in-flight operation\" (a second `START` while\n * busy is ignored) and how terminal states stay put.\n *\n * @param state - Current machine state.\n * @param event - Event to apply.\n * @returns The next state (or the same state for unhandled events).\n */\nexport function transition(\n  state: WalletRegistrationState,\n  event: WalletRegistrationEvent,\n): WalletRegistrationState {\n  const handler = TABLE[state.status]?.[event.type];\n  return handler ? handler(state, event) : state;\n}\n"]}