{
+ const { signer, isLoading } = useSessionContext()
+ const widget = widgetRegistry.get(widgetId)
+
+ useEffect(() => {
+ if (widget) {
+ setBottomSheetProps({
+ title: widget.displayName,
+ subtitle: widget.description,
+ })
+ }
+ return () => setBottomSheetProps({})
+ }, [widget])
+
+ if (!widget) throw new Error(`Unknown widget route: ${widgetId}`)
+ if (isLoading) return
+ if (!signer?.EVM) return null
+
+ return (
+
+
+
+ )
+}
+
+/**
+ * The provider capability enters the renderer only after authentication.
+ */
+const MountedWidget = ({
+ widget,
+ themeOverrides,
+ config,
+}: {
+ widget: RegisteredWidget
+ themeOverrides?: WidgetHostProps["themeOverrides"]
+ config?: WidgetHostProps["config"]
+}) => {
+ const provider = useWidgetProvider()
+
+ return (
+
+ )
+}
diff --git a/src/widgets/WidgetRenderer.tsx b/src/widgets/WidgetRenderer.tsx
new file mode 100644
index 0000000..6922033
--- /dev/null
+++ b/src/widgets/WidgetRenderer.tsx
@@ -0,0 +1,34 @@
+"use client"
+
+import { ReactWidgetHost } from "./hosts/ReactWidgetHost"
+import { WebComponentWidgetHost } from "./hosts/WebComponentWidgetHost"
+import type { WidgetHostProps } from "./hostTypes"
+import { type RegisteredWidget, resolveWidgetIntegrationMode } from "./registry"
+
+/**
+ * This is the sole integration-mode decision point for every widget route.
+ */
+export const WidgetRenderer = ({
+ widget,
+ ...hostProps
+}: WidgetHostProps & {
+ widget: RegisteredWidget
+}) => {
+ if (resolveWidgetIntegrationMode(widget) === "react") {
+ return (
+
+ )
+ }
+
+ return (
+
+ )
+}
diff --git a/src/widgets/hostProperties.test.ts b/src/widgets/hostProperties.test.ts
new file mode 100644
index 0000000..c13a3e9
--- /dev/null
+++ b/src/widgets/hostProperties.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest"
+
+import {
+ assignHostedWidgetProperties,
+ clearHostedWidgetProperties,
+} from "./hostProperties"
+import type { HostedWidgetElement } from "./hostTypes"
+import type { RestrictedEip1193Provider } from "./provider/RestrictedEip1193Provider"
+
+describe("Web Component host properties", () => {
+ it("hands objects over by identity and clears Wallet references on cleanup", () => {
+ const provider = {} as RestrictedEip1193Provider
+ const element = {} as HostedWidgetElement
+ const themeOverrides = { color: { primary: "#00AFFE" } }
+ const config = { environment: "production" }
+
+ assignHostedWidgetProperties(element, {
+ provider,
+ themeOverrides,
+ config,
+ })
+
+ expect(element.provider).toBe(provider)
+ expect(element.themeOverrides).toBe(themeOverrides)
+ expect(element.config).toBe(config)
+
+ clearHostedWidgetProperties(element)
+
+ expect(element.provider).toBeNull()
+ expect(element.themeOverrides).toBeUndefined()
+ expect(element.config).toBeUndefined()
+ })
+})
diff --git a/src/widgets/hostProperties.ts b/src/widgets/hostProperties.ts
new file mode 100644
index 0000000..bf8214b
--- /dev/null
+++ b/src/widgets/hostProperties.ts
@@ -0,0 +1,24 @@
+import type { HostedWidgetElement, WidgetHostProps } from "./hostTypes"
+
+/**
+ * Hands the non-serializable wallet capability to the mounted Custom Element.
+ */
+export const assignHostedWidgetProperties = (
+ element: HostedWidgetElement,
+ { provider, themeOverrides, config }: WidgetHostProps,
+): void => {
+ element.provider = provider
+ element.themeOverrides = themeOverrides
+ element.config = config
+}
+
+/**
+ * Removes wallet-owned references before a detached element can retain them.
+ */
+export const clearHostedWidgetProperties = (
+ element: HostedWidgetElement,
+): void => {
+ element.provider = null
+ element.themeOverrides = undefined
+ element.config = undefined
+}
diff --git a/src/widgets/hostTypes.ts b/src/widgets/hostTypes.ts
new file mode 100644
index 0000000..b0bd7ba
--- /dev/null
+++ b/src/widgets/hostTypes.ts
@@ -0,0 +1,39 @@
+import type { ComponentType } from "react"
+
+import type { RestrictedEip1193Provider } from "./provider/RestrictedEip1193Provider"
+
+/**
+ * This is the complete wallet-to-widget contract for both host implementations.
+ * Widgets do not receive a signer, seed, RPC client, or wallet session object.
+ */
+export type WidgetHostProps = {
+ provider: RestrictedEip1193Provider
+ themeOverrides?: Record
+ config?: Record
+}
+
+/**
+ * Registry loaders deliberately return an untyped module because independently
+ * released widgets are normalized by the host before they are rendered.
+ */
+export type ReactWidgetLoader = () => Promise>
+
+export type HostedReactWidget = ComponentType
+
+/**
+ * The element module must register its declared tag only after the host mounts
+ * in the browser, avoiding Custom Element evaluation during server rendering.
+ */
+export type WebComponentWidgetLoader = () => Promise<{
+ register: (tagName?: string) => string | Promise
+}>
+
+/**
+ * Widget values are object properties, rather than HTML attributes, so the
+ * restricted provider never appears in serialized markup.
+ */
+export type HostedWidgetElement = HTMLElement & {
+ provider: RestrictedEip1193Provider | null
+ themeOverrides?: Record
+ config?: Record
+}
diff --git a/src/widgets/hosts/ReactWidgetHost.tsx b/src/widgets/hosts/ReactWidgetHost.tsx
new file mode 100644
index 0000000..bbd8cfe
--- /dev/null
+++ b/src/widgets/hosts/ReactWidgetHost.tsx
@@ -0,0 +1,57 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+import { LoadingSpinner } from "@/components/Snippet/LoadingSpinner"
+
+import type {
+ HostedReactWidget,
+ ReactWidgetLoader,
+ WidgetHostProps,
+} from "../hostTypes"
+import { resolveReactWidget } from "../resolveReactWidget"
+
+/**
+ * Loads a reviewed React entry only after this bottom-sheet route reaches the
+ * browser and passes it the same limited contract as Custom Elements receive.
+ */
+export const ReactWidgetHost = ({
+ load,
+ exportName,
+ ...hostProps
+}: WidgetHostProps & {
+ load: ReactWidgetLoader
+ exportName: string
+}) => {
+ const [Component, setComponent] = useState(null)
+ const [loadError, setLoadError] = useState(null)
+
+ useEffect(() => {
+ let isMounted = true
+
+ load()
+ .then((module) => {
+ if (!isMounted) return
+ const exportedComponent = resolveReactWidget(module, exportName)
+ // Functions are React state updaters, so keep the component wrapped.
+ setComponent(() => exportedComponent)
+ })
+ .catch((error: unknown) => {
+ if (!isMounted) return
+ setLoadError(
+ error instanceof Error
+ ? error
+ : new Error("Unable to load the widget React entry"),
+ )
+ })
+
+ return () => {
+ isMounted = false
+ }
+ }, [exportName, load])
+
+ if (loadError) throw loadError
+ if (!Component) return
+
+ return
+}
diff --git a/src/widgets/hosts/WebComponentWidgetHost.tsx b/src/widgets/hosts/WebComponentWidgetHost.tsx
new file mode 100644
index 0000000..7917046
--- /dev/null
+++ b/src/widgets/hosts/WebComponentWidgetHost.tsx
@@ -0,0 +1,89 @@
+"use client"
+
+import { createElement, useEffect, useRef, useState } from "react"
+
+import { LoadingSpinner } from "@/components/Snippet/LoadingSpinner"
+
+import {
+ assignHostedWidgetProperties,
+ clearHostedWidgetProperties,
+} from "../hostProperties"
+import type {
+ HostedWidgetElement,
+ WebComponentWidgetLoader,
+ WidgetHostProps,
+} from "../hostTypes"
+
+/**
+ * Registers and mounts a widget Custom Element exclusively on the client.
+ */
+export const WebComponentWidgetHost = ({
+ load,
+ tagName,
+ provider,
+ themeOverrides,
+ config,
+}: WidgetHostProps & {
+ load: WebComponentWidgetLoader
+ tagName: string
+}) => {
+ const elementRef = useRef(null)
+ const [registeredTagName, setRegisteredTagName] = useState(
+ null,
+ )
+ const [loadError, setLoadError] = useState(null)
+
+ useEffect(() => {
+ let isMounted = true
+
+ // Element classes may depend on HTMLElement at module evaluation time.
+ load()
+ .then(async (module) => {
+ const registered = await module.register(tagName)
+ if (!isMounted) return
+ if (registered !== tagName) {
+ throw new Error(
+ `Widget registered ${registered}; expected declared tag ${tagName}`,
+ )
+ }
+ setRegisteredTagName(registered)
+ })
+ .catch((error: unknown) => {
+ if (!isMounted) return
+ setLoadError(
+ error instanceof Error
+ ? error
+ : new Error("Unable to register the widget Custom Element"),
+ )
+ })
+
+ return () => {
+ isMounted = false
+ }
+ }, [load, tagName])
+
+ useEffect(() => {
+ const element = elementRef.current
+ if (!element || !registeredTagName) return
+
+ // Object assignment preserves provider identity and prevents HTML leakage.
+ assignHostedWidgetProperties(element, {
+ provider,
+ themeOverrides,
+ config,
+ })
+
+ return () => {
+ clearHostedWidgetProperties(element)
+ }
+ }, [config, provider, registeredTagName, themeOverrides])
+
+ if (loadError) throw loadError
+ if (!registeredTagName) return
+
+ return createElement(registeredTagName, {
+ ref: (element: HTMLElement | null) => {
+ elementRef.current = element as HostedWidgetElement | null
+ },
+ })
+}
diff --git a/src/widgets/provider/RestrictedEip1193Provider.test.ts b/src/widgets/provider/RestrictedEip1193Provider.test.ts
new file mode 100644
index 0000000..892de54
--- /dev/null
+++ b/src/widgets/provider/RestrictedEip1193Provider.test.ts
@@ -0,0 +1,159 @@
+import { describe, expect, it, vi } from "vitest"
+
+vi.mock("@/chain/provider/EVM/viemClients", () => ({
+ getViemClient: vi.fn(),
+}))
+
+import {
+ RestrictedEip1193Provider,
+ WidgetProviderError,
+} from "./RestrictedEip1193Provider"
+
+const address = "0x1111111111111111111111111111111111111111"
+const signer = {
+ address,
+ signMessage: vi.fn(async () => "0xmessage"),
+ signTypedData: vi.fn(async () => "0xtyped"),
+ signTransaction: vi.fn(async () => "0xraw"),
+}
+
+const allTestMethods = [
+ "eth_accounts",
+ "eth_chainId",
+ "eth_getBalance",
+ "wallet_switchEthereumChain",
+ "personal_sign",
+ "eth_signTypedData_v4",
+ "eth_sendTransaction",
+]
+
+const createProvider = (
+ options: Partial<
+ ConstructorParameters[0]
+ > = {},
+) => {
+ const rpcRequest = vi.fn(async () => "0xresult")
+ const requestWalletApproval = vi.fn(async () => true)
+ return {
+ provider: new RestrictedEip1193Provider({
+ signer,
+ chainIds: [1, 42220],
+ rpcRequest,
+ requestWalletApproval,
+ ...options,
+ requiredMethods: options.requiredMethods ?? allTestMethods,
+ }),
+ rpcRequest,
+ requestWalletApproval,
+ }
+}
+
+describe("RestrictedEip1193Provider", () => {
+ it("exposes only the active account and forwards reviewed reads", async () => {
+ const { provider, rpcRequest } = createProvider()
+ await expect(provider.request({ method: "eth_accounts" })).resolves.toEqual(
+ [address],
+ )
+ await expect(
+ provider.request({
+ method: "eth_getBalance",
+ params: [address, "latest"],
+ }),
+ ).resolves.toBe("0xresult")
+ expect(rpcRequest).toHaveBeenCalledWith(1, {
+ method: "eth_getBalance",
+ params: [address, "latest"],
+ })
+ })
+
+ it("enforces each widget's configured method subset", async () => {
+ const { provider } = createProvider({
+ requiredMethods: ["eth_accounts"],
+ })
+ await expect(
+ provider.request({
+ method: "eth_getBalance",
+ params: [address, "latest"],
+ }),
+ ).rejects.toMatchObject({ code: 4100 })
+ })
+
+ it("rejects unknown methods and incompatible provider contracts", async () => {
+ const { provider } = createProvider()
+ await expect(
+ provider.request({ method: "wallet_getSeed" }),
+ ).rejects.toMatchObject({ code: 4200 })
+ expect(() =>
+ createProvider({ requiredMethods: ["wallet_getSeed"] }),
+ ).toThrow("unsupported provider methods")
+ })
+
+ it("allows only configured chain switches and emits normalized chain IDs", async () => {
+ const { provider } = createProvider()
+ const listener = vi.fn()
+ provider.on("chainChanged", listener)
+ await provider.request({
+ method: "wallet_switchEthereumChain",
+ params: [{ chainId: "0xa4ec" }],
+ })
+ expect(listener).toHaveBeenCalledWith("0xa4ec")
+ await expect(
+ provider.request({
+ method: "wallet_switchEthereumChain",
+ params: [{ chainId: "0x89" }],
+ }),
+ ).rejects.toBeInstanceOf(WidgetProviderError)
+ })
+
+ it("requires account and chain validation plus Wallet approval for transactions", async () => {
+ const { provider, requestWalletApproval, rpcRequest } = createProvider()
+ await expect(
+ provider.request({
+ method: "eth_sendTransaction",
+ params: [{ from: address, chainId: 1, to: address, value: BigInt(1) }],
+ }),
+ ).resolves.toBe("0xresult")
+ expect(requestWalletApproval).toHaveBeenCalledWith(
+ expect.objectContaining({ method: "eth_sendTransaction", chainId: 1 }),
+ )
+ expect(signer.signTransaction).toHaveBeenCalled()
+ expect(rpcRequest).toHaveBeenCalledWith(1, {
+ method: "eth_sendRawTransaction",
+ params: ["0xraw"],
+ })
+ })
+
+ it("keeps signing disabled until the Wallet explicitly approves it", async () => {
+ const { provider } = createProvider({ requestWalletApproval: undefined })
+ await expect(
+ provider.request({
+ method: "personal_sign",
+ params: ["message", address],
+ }),
+ ).rejects.toMatchObject({ code: 4001 })
+ })
+
+ it("rejects mismatched signing accounts and typed-data chains before approval", async () => {
+ const { provider, requestWalletApproval } = createProvider()
+ await expect(
+ provider.request({
+ method: "personal_sign",
+ params: ["message", "0x2222222222222222222222222222222222222222"],
+ }),
+ ).rejects.toMatchObject({ code: 4100 })
+ await expect(
+ provider.request({
+ method: "eth_signTypedData_v4",
+ params: [
+ address,
+ JSON.stringify({
+ domain: { name: "Widget", chainId: 42220 },
+ types: { Thing: [{ name: "value", type: "uint256" }] },
+ message: { value: 1 },
+ }),
+ ],
+ }),
+ ).rejects.toMatchObject({ code: 4100 })
+ expect(requestWalletApproval).not.toHaveBeenCalled()
+ })
+})
diff --git a/src/widgets/provider/RestrictedEip1193Provider.ts b/src/widgets/provider/RestrictedEip1193Provider.ts
new file mode 100644
index 0000000..2e294e8
--- /dev/null
+++ b/src/widgets/provider/RestrictedEip1193Provider.ts
@@ -0,0 +1,334 @@
+import type {
+ TransactionRequest,
+ TypedDataDomain,
+ TypedDataField,
+} from "ethers"
+import { getBytes } from "ethers"
+
+import { getViemClient } from "@/chain/provider/EVM/viemClients"
+import type { EVMSigner } from "@/login"
+
+import {
+ WIDGET_EVM_CHAIN_IDS,
+ WIDGET_PROVIDER_METHODS,
+ WIDGET_READ_METHODS,
+} from "./policy"
+
+export type ProviderRequest = {
+ method: string
+ params?: readonly unknown[] | Record
+}
+
+export type WalletApprovalRequest = {
+ method: string
+ params: readonly unknown[]
+ account: string
+ chainId: number
+}
+
+export class WidgetProviderError extends Error {
+ constructor(
+ public readonly code: 4001 | 4100 | 4200 | 4901,
+ message: string,
+ public readonly data?: unknown,
+ ) {
+ super(message)
+ this.name = "WidgetProviderError"
+ }
+}
+
+export type RestrictedProviderOptions = {
+ signer: EVMSigner
+ chainIds: readonly number[]
+ requiredMethods: readonly string[]
+ initialChainId?: number
+ /**
+ * This callback belongs to GoodWallet UI, never to the widget. Its secure
+ * default leaves every signing method disabled until that UI is supplied.
+ */
+ requestWalletApproval?: (request: WalletApprovalRequest) => Promise
+ rpcRequest?: (chainId: number, request: ProviderRequest) => Promise
+}
+
+const asParams = (params: ProviderRequest["params"]): readonly unknown[] =>
+ Array.isArray(params) ? params : []
+
+const asChainId = (value: unknown): number => {
+ if (typeof value !== "string" || !/^0x[0-9a-f]+$/i.test(value)) {
+ throw new WidgetProviderError(4200, "Invalid hexadecimal chain ID")
+ }
+ return Number.parseInt(value, 16)
+}
+
+const addressesMatch = (left: unknown, right: string): boolean =>
+ typeof left === "string" && left.toLowerCase() === right.toLowerCase()
+
+const normalizeError = (error: unknown): WidgetProviderError => {
+ if (error instanceof WidgetProviderError) return error
+ const message =
+ error instanceof Error ? error.message : "Provider request failed"
+ const rejected = /reject|denied|declined|cancel/i.test(message)
+ return new WidgetProviderError(rejected ? 4001 : 4200, message, error)
+}
+
+/**
+ * A capability-limited EIP-1193 facade over GoodWallet's active EVM session.
+ * The real signer and session are private fields and cannot be retrieved by a
+ * widget through this interface.
+ */
+export class RestrictedEip1193Provider {
+ readonly #allowedChainIds: ReadonlySet
+ readonly #allowedMethods: ReadonlySet
+ readonly #listeners = new Map<
+ "accountsChanged" | "chainChanged",
+ Set<(...args: unknown[]) => void>
+ >()
+ readonly #requestWalletApproval: NonNullable<
+ RestrictedProviderOptions["requestWalletApproval"]
+ >
+ readonly #rpcRequest: NonNullable
+ #chainId: number
+ #signer: EVMSigner
+
+ constructor(options: RestrictedProviderOptions) {
+ if (options.chainIds.length === 0) {
+ throw new Error("At least one widget chain is required")
+ }
+
+ const unsupportedChains = options.chainIds.filter(
+ (chainId) => !WIDGET_EVM_CHAIN_IDS.has(chainId),
+ )
+ if (unsupportedChains.length > 0) {
+ throw new Error(
+ `Widget requested unsupported chains: ${unsupportedChains.join(", ")}`,
+ )
+ }
+
+ const unsupportedMethods = options.requiredMethods.filter(
+ (method) => !WIDGET_PROVIDER_METHODS.has(method),
+ )
+ if (unsupportedMethods.length > 0) {
+ throw new Error(
+ `Widget requires unsupported provider methods: ${unsupportedMethods.join(", ")}`,
+ )
+ }
+
+ this.#allowedChainIds = new Set(options.chainIds)
+ this.#allowedMethods = new Set(options.requiredMethods)
+ this.#chainId = options.initialChainId ?? options.chainIds[0]
+ if (!this.#allowedChainIds.has(this.#chainId)) {
+ throw new Error("The initial chain must be allowed")
+ }
+
+ this.#signer = options.signer
+ // Signing is disabled unless a Wallet-owned confirmation surface opts in.
+ this.#requestWalletApproval =
+ options.requestWalletApproval ?? (async () => false)
+ this.#rpcRequest =
+ options.rpcRequest ??
+ (async (chainId, request) => {
+ const client = getViemClient(chainId)
+ return await (
+ client.request as (request: ProviderRequest) => Promise
+ )(request)
+ })
+ }
+
+ get chainId(): number {
+ return this.#chainId
+ }
+
+ get supportedMethods(): readonly string[] {
+ return [...this.#allowedMethods]
+ }
+
+ on(
+ event: "accountsChanged" | "chainChanged",
+ listener: (...args: unknown[]) => void,
+ ): this {
+ const listeners = this.#listeners.get(event) ?? new Set()
+ listeners.add(listener)
+ this.#listeners.set(event, listeners)
+ return this
+ }
+
+ removeListener(
+ event: "accountsChanged" | "chainChanged",
+ listener: (...args: unknown[]) => void,
+ ): this {
+ this.#listeners.get(event)?.delete(listener)
+ return this
+ }
+
+ /**
+ * Session updates retain the facade while notifying a widget of account loss.
+ */
+ updateAccount(signer: EVMSigner): void {
+ const accountChanged = !addressesMatch(signer.address, this.#signer.address)
+ this.#signer = signer
+ if (accountChanged) this.#emit("accountsChanged", [signer.address])
+ }
+
+ async request(request: ProviderRequest): Promise {
+ if (!WIDGET_PROVIDER_METHODS.has(request.method)) {
+ throw new WidgetProviderError(
+ 4200,
+ `Method ${request.method} is not permitted for widgets`,
+ )
+ }
+ if (!this.#allowedMethods.has(request.method)) {
+ throw new WidgetProviderError(
+ 4100,
+ `Method ${request.method} is not approved for this widget`,
+ )
+ }
+
+ try {
+ const params = asParams(request.params)
+ switch (request.method) {
+ case "eth_accounts":
+ case "eth_requestAccounts":
+ return [this.#signer.address]
+ case "eth_chainId":
+ return `0x${this.#chainId.toString(16)}`
+ case "wallet_switchEthereumChain":
+ return this.#switchChain(params)
+ case "personal_sign":
+ return await this.#signMessage(params)
+ case "eth_signTypedData_v4":
+ return await this.#signTypedData(params)
+ case "eth_sendTransaction":
+ return await this.#sendTransaction(params)
+ default:
+ if (WIDGET_READ_METHODS.has(request.method)) {
+ return await this.#rpcRequest(this.#chainId, request)
+ }
+ throw new WidgetProviderError(4200, "Unsupported widget request")
+ }
+ } catch (error) {
+ throw normalizeError(error)
+ }
+ }
+
+ #emit(event: "accountsChanged" | "chainChanged", value: unknown): void {
+ for (const listener of this.#listeners.get(event) ?? []) listener(value)
+ }
+
+ #assertAccount(account: unknown): void {
+ if (!addressesMatch(account, this.#signer.address)) {
+ throw new WidgetProviderError(
+ 4100,
+ "The signing account does not match the active GoodWallet session",
+ )
+ }
+ }
+
+ async #requestSigningApproval(
+ method: string,
+ params: readonly unknown[],
+ ): Promise {
+ const approved = await this.#requestWalletApproval({
+ method,
+ params,
+ account: this.#signer.address,
+ chainId: this.#chainId,
+ })
+ if (!approved) {
+ throw new WidgetProviderError(
+ 4001,
+ "GoodWallet did not approve the signing request",
+ )
+ }
+ }
+
+ #switchChain(params: readonly unknown[]): null {
+ const requested = params[0]
+ const rawChainId =
+ requested && typeof requested === "object" && "chainId" in requested
+ ? requested.chainId
+ : undefined
+ const chainId = asChainId(rawChainId)
+ if (!this.#allowedChainIds.has(chainId)) {
+ throw new WidgetProviderError(
+ 4901,
+ `Chain ${chainId} is not allowed for this widget`,
+ )
+ }
+ if (chainId !== this.#chainId) {
+ this.#chainId = chainId
+ this.#emit("chainChanged", `0x${chainId.toString(16)}`)
+ }
+ return null
+ }
+
+ async #signMessage(params: readonly unknown[]): Promise {
+ const [message, account] = params
+ this.#assertAccount(account)
+ if (typeof message !== "string") {
+ throw new WidgetProviderError(4200, "personal_sign requires a message")
+ }
+ await this.#requestSigningApproval("personal_sign", params)
+ return await this.#signer.signMessage(
+ /^0x[0-9a-f]*$/i.test(message) ? getBytes(message) : message,
+ )
+ }
+
+ async #signTypedData(params: readonly unknown[]): Promise {
+ const [account, rawData] = params
+ this.#assertAccount(account)
+ if (typeof rawData !== "string") {
+ throw new WidgetProviderError(
+ 4200,
+ "eth_signTypedData_v4 requires JSON typed data",
+ )
+ }
+ const data = JSON.parse(rawData) as {
+ domain?: TypedDataDomain
+ types?: Record
+ message?: Record
+ }
+ if (!data.domain || !data.types || !data.message) {
+ throw new WidgetProviderError(4200, "Invalid EIP-712 typed data")
+ }
+ const { EIP712Domain: _domainType, ...types } = data.types
+ if (
+ data.domain.chainId !== undefined &&
+ Number(data.domain.chainId) !== this.#chainId
+ ) {
+ throw new WidgetProviderError(
+ 4100,
+ "Typed-data chain does not match the active widget chain",
+ )
+ }
+ await this.#requestSigningApproval("eth_signTypedData_v4", params)
+ return await this.#signer.signTypedData(data.domain, types, data.message)
+ }
+
+ async #sendTransaction(params: readonly unknown[]): Promise {
+ const transaction = params[0]
+ if (!transaction || typeof transaction !== "object") {
+ throw new WidgetProviderError(4200, "A transaction object is required")
+ }
+ const request = transaction as TransactionRequest & {
+ from?: string
+ chainId?: string | number
+ }
+ this.#assertAccount(request.from)
+ if (
+ request.chainId !== undefined &&
+ Number(request.chainId) !== this.#chainId
+ ) {
+ throw new WidgetProviderError(
+ 4100,
+ "Transaction chain does not match the active widget chain",
+ )
+ }
+ await this.#requestSigningApproval("eth_sendTransaction", params)
+ const { from: _from, ...signableRequest } = request
+ const rawTransaction = await this.#signer.signTransaction(signableRequest)
+ return await this.#rpcRequest(this.#chainId, {
+ method: "eth_sendRawTransaction",
+ params: [rawTransaction],
+ })
+ }
+}
diff --git a/src/widgets/provider/WidgetProvider.tsx b/src/widgets/provider/WidgetProvider.tsx
new file mode 100644
index 0000000..f807577
--- /dev/null
+++ b/src/widgets/provider/WidgetProvider.tsx
@@ -0,0 +1,63 @@
+"use client"
+
+import {
+ createContext,
+ type ReactNode,
+ useContext,
+ useEffect,
+ useMemo,
+} from "react"
+
+import { useSessionContext } from "@/login/hooks/context"
+
+import { RestrictedEip1193Provider } from "./RestrictedEip1193Provider"
+
+const WidgetProviderContext = createContext(
+ null,
+)
+
+/**
+ * This is the sole bridge from an authenticated session into widget code.
+ */
+export const WidgetProvider = ({
+ chainIds,
+ requiredMethods,
+ children,
+}: {
+ chainIds: readonly number[]
+ requiredMethods: readonly string[]
+ children: ReactNode
+}) => {
+ const { signer } = useSessionContext()
+ const evmSigner = signer?.EVM
+ const provider = useMemo(
+ () =>
+ evmSigner
+ ? new RestrictedEip1193Provider({
+ signer: evmSigner,
+ chainIds,
+ requiredMethods,
+ })
+ : null,
+ [evmSigner, chainIds, requiredMethods],
+ )
+
+ useEffect(() => {
+ if (provider && evmSigner) provider.updateAccount(evmSigner)
+ }, [evmSigner, provider])
+
+ if (!provider) return null
+ return (
+
+ {children}
+
+ )
+}
+
+export const useWidgetProvider = (): RestrictedEip1193Provider => {
+ const provider = useContext(WidgetProviderContext)
+ if (!provider) {
+ throw new Error("useWidgetProvider must be used inside WidgetProvider")
+ }
+ return provider
+}
diff --git a/src/widgets/provider/policy.ts b/src/widgets/provider/policy.ts
new file mode 100644
index 0000000..3074ae5
--- /dev/null
+++ b/src/widgets/provider/policy.ts
@@ -0,0 +1,65 @@
+import {
+ BASE_CHAIN_ID,
+ BNB_CHAIN_ID,
+ CELO_CHAIN_ID,
+ ETHEREUM_CHAIN_ID,
+ FUSE_CHAIN_ID,
+ HOODI_CHAIN_ID,
+ OPTIMISM_CHAIN_ID,
+ POLYGON_CHAIN_ID,
+ SEPOLIA_CHAIN_ID,
+ XDC_CHAIN_ID,
+} from "@/chain/chain-ids"
+
+/**
+ * This central allowlist is the outer security boundary for every in-process
+ * widget. Registry entries can narrow it, but cannot broaden it.
+ */
+export const WIDGET_READ_METHODS = new Set([
+ "eth_blockNumber",
+ "eth_call",
+ "eth_estimateGas",
+ "eth_feeHistory",
+ "eth_gasPrice",
+ "eth_getBalance",
+ "eth_getBlockByHash",
+ "eth_getBlockByNumber",
+ "eth_getBlockTransactionCountByHash",
+ "eth_getBlockTransactionCountByNumber",
+ "eth_getCode",
+ "eth_getLogs",
+ "eth_getStorageAt",
+ "eth_getTransactionByHash",
+ "eth_getTransactionCount",
+ "eth_getTransactionReceipt",
+ "eth_maxPriorityFeePerGas",
+ "net_version",
+])
+
+export const WIDGET_SIGNING_METHODS = new Set([
+ "personal_sign",
+ "eth_signTypedData_v4",
+ "eth_sendTransaction",
+])
+
+export const WIDGET_PROVIDER_METHODS = new Set([
+ "eth_accounts",
+ "eth_requestAccounts",
+ "eth_chainId",
+ "wallet_switchEthereumChain",
+ ...WIDGET_READ_METHODS,
+ ...WIDGET_SIGNING_METHODS,
+])
+
+export const WIDGET_EVM_CHAIN_IDS = new Set([
+ ETHEREUM_CHAIN_ID,
+ OPTIMISM_CHAIN_ID,
+ XDC_CHAIN_ID,
+ BNB_CHAIN_ID,
+ FUSE_CHAIN_ID,
+ POLYGON_CHAIN_ID,
+ BASE_CHAIN_ID,
+ CELO_CHAIN_ID,
+ SEPOLIA_CHAIN_ID,
+ HOODI_CHAIN_ID,
+])
diff --git a/src/widgets/registry.test.ts b/src/widgets/registry.test.ts
new file mode 100644
index 0000000..e2b2da5
--- /dev/null
+++ b/src/widgets/registry.test.ts
@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest"
+
+import {
+ coreDashboardActions,
+ createWidgetRegistry,
+ DEFAULT_WIDGET_INTEGRATION_MODE,
+ defineWidget,
+ resolveWidgetIntegrationMode,
+} from "./registry"
+
+const widget = defineWidget({
+ widgetId: "goodwidget.goodreserve",
+ packageName: "@goodwidget/goodreserve-widget",
+ packageVersion: "1.0.0",
+ entries: {
+ react: {
+ exportName: "GoodReserveWidget",
+ load: async () => ({ GoodReserveWidget: () => null }),
+ },
+ webComponent: {
+ tagName: "gw-goodreserve-widget",
+ load: async () => ({ register: (tagName) => tagName ?? "unused" }),
+ },
+ },
+ routeSlug: "goodreserve",
+ displayName: "GoodReserve",
+ description: "Reserve",
+ icon: { kind: "system", name: "Cash" },
+ providerPolicy: {
+ chainIds: [1, 42220],
+ requiredMethods: ["eth_accounts", "eth_chainId"],
+ },
+})
+
+describe("widget registry", () => {
+ it("indexes typed widgets by immutable ID", () => {
+ expect(createWidgetRegistry([widget]).get(widget.widgetId)).toBe(widget)
+ })
+
+ it("defaults to Web Components and permits a reviewed React override", () => {
+ expect(DEFAULT_WIDGET_INTEGRATION_MODE).toBe("web-component")
+ expect(resolveWidgetIntegrationMode(widget)).toBe("web-component")
+ expect(
+ resolveWidgetIntegrationMode({ ...widget, integrationMode: "react" }),
+ ).toBe("react")
+ })
+
+ it("rejects duplicate IDs and routes", () => {
+ expect(() => createWidgetRegistry([widget, widget])).toThrow(
+ "Duplicate widget ID",
+ )
+ expect(() =>
+ createWidgetRegistry([
+ widget,
+ { ...widget, widgetId: "goodwidget.other" },
+ ]),
+ ).toThrow("Duplicate widget route")
+ })
+
+ it("rejects non-exact package versions and unsupported policy entries", () => {
+ expect(() =>
+ createWidgetRegistry([{ ...widget, packageVersion: "^1.0.0" } as never]),
+ ).toThrow("exact package version")
+ expect(() =>
+ createWidgetRegistry([
+ {
+ ...widget,
+ providerPolicy: { ...widget.providerPolicy, chainIds: [999] },
+ } as never,
+ ]),
+ ).toThrow("unsupported chains")
+ expect(() =>
+ createWidgetRegistry([
+ {
+ ...widget,
+ providerPolicy: {
+ ...widget.providerPolicy,
+ requiredMethods: ["wallet_getSeed"],
+ },
+ } as never,
+ ]),
+ ).toThrow("unsupported methods")
+ })
+
+ it("keeps the six reviewed core actions ahead of widget actions", () => {
+ expect(coreDashboardActions.map(({ id }) => id)).toEqual([
+ "gooddollar",
+ "send",
+ "receive",
+ "swap",
+ "predictions",
+ "walletconnect",
+ ])
+ })
+})
diff --git a/src/widgets/registry.ts b/src/widgets/registry.ts
new file mode 100644
index 0000000..a5e3730
--- /dev/null
+++ b/src/widgets/registry.ts
@@ -0,0 +1,193 @@
+import type { ReactNode } from "react"
+import type { IconName } from "ui"
+
+import type { ReactWidgetLoader, WebComponentWidgetLoader } from "./hostTypes"
+import {
+ WIDGET_EVM_CHAIN_IDS,
+ WIDGET_PROVIDER_METHODS,
+} from "./provider/policy"
+
+export type WidgetIntegrationMode = "web-component" | "react"
+
+/**
+ * Custom Elements are the normal plugin boundary; React is an explicit,
+ * reviewed exception for packages which cannot expose a Custom Element.
+ */
+export const DEFAULT_WIDGET_INTEGRATION_MODE: WidgetIntegrationMode =
+ "web-component"
+
+export type DashboardIcon =
+ | { kind: "system"; name: IconName }
+ | { kind: "local"; render: () => ReactNode }
+
+export type DashboardAction = {
+ id: string
+ routeSlug: string
+ label: string
+ icon: DashboardIcon
+ widgetId?: string
+}
+
+/**
+ * A registry entry is reviewed source rather than remote widget metadata.
+ * This prevents a package or its manifest from enlarging wallet authority.
+ */
+export type RegisteredWidget = {
+ widgetId: `goodwidget.${string}`
+ packageName: `@goodwidget/${string}`
+ packageVersion: `${number}.${number}.${number}`
+ integrationMode?: WidgetIntegrationMode
+ entries: {
+ react: { exportName: string; load: ReactWidgetLoader }
+ webComponent: {
+ tagName: `${string}-${string}`
+ load: WebComponentWidgetLoader
+ }
+ }
+ routeSlug: string
+ displayName: string
+ description: string
+ icon: DashboardIcon
+ providerPolicy: {
+ chainIds: readonly number[]
+ requiredMethods: readonly string[]
+ }
+}
+
+export const defineWidget = (widget: T): T =>
+ widget
+
+export const resolveWidgetIntegrationMode = (
+ widget: RegisteredWidget,
+): WidgetIntegrationMode =>
+ widget.integrationMode ?? DEFAULT_WIDGET_INTEGRATION_MODE
+
+const EXACT_PACKAGE_VERSION = /^\d+\.\d+\.\d+$/
+const ROUTE_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+
+/**
+ * Validates every security-sensitive registry field before it becomes routable.
+ */
+const validateWidget = (widget: RegisteredWidget): void => {
+ if (!EXACT_PACKAGE_VERSION.test(widget.packageVersion)) {
+ throw new Error(
+ `Widget ${widget.widgetId} must use an exact package version`,
+ )
+ }
+ if (!ROUTE_SLUG.test(widget.routeSlug)) {
+ throw new Error(`Widget ${widget.widgetId} has an invalid route slug`)
+ }
+ const unsupportedChains = widget.providerPolicy.chainIds.filter(
+ (chainId) => !WIDGET_EVM_CHAIN_IDS.has(chainId),
+ )
+ if (unsupportedChains.length > 0) {
+ throw new Error(
+ `Widget ${widget.widgetId} requests unsupported chains: ${unsupportedChains.join(", ")}`,
+ )
+ }
+ if (
+ new Set(widget.providerPolicy.chainIds).size !==
+ widget.providerPolicy.chainIds.length
+ ) {
+ throw new Error(`Widget ${widget.widgetId} repeats a provider chain`)
+ }
+ const unsupportedMethods = widget.providerPolicy.requiredMethods.filter(
+ (method) => !WIDGET_PROVIDER_METHODS.has(method),
+ )
+ if (unsupportedMethods.length > 0) {
+ throw new Error(
+ `Widget ${widget.widgetId} requests unsupported methods: ${unsupportedMethods.join(", ")}`,
+ )
+ }
+}
+
+/**
+ * Creates both identity and route indexes, rejecting collisions at module load.
+ */
+export const createWidgetRegistry = (
+ widgets: readonly RegisteredWidget[],
+): ReadonlyMap => {
+ const registry = new Map()
+ const routes = new Set()
+
+ for (const widget of widgets) {
+ validateWidget(widget)
+ if (registry.has(widget.widgetId)) {
+ throw new Error(`Duplicate widget ID: ${widget.widgetId}`)
+ }
+ if (routes.has(widget.routeSlug)) {
+ throw new Error(`Duplicate widget route: ${widget.routeSlug}`)
+ }
+ registry.set(widget.widgetId, widget)
+ routes.add(widget.routeSlug)
+ }
+
+ return registry
+}
+
+/**
+ * Add a released package only with literal import loaders and its exact version.
+ * No package is registered until a reviewed widget-specific follow-up exists.
+ */
+export const WIDGETS: readonly RegisteredWidget[] = []
+export const widgetRegistry = createWidgetRegistry(WIDGETS)
+
+export const getWidgetByRoute = (
+ routeSlug: string,
+): RegisteredWidget | undefined =>
+ WIDGETS.find((widget) => widget.routeSlug === routeSlug)
+
+/**
+ * These six action IDs preserve the existing dashboard order and behavior.
+ */
+export const coreDashboardActions = [
+ {
+ id: "gooddollar",
+ routeSlug: "gooddollar",
+ label: "GoodDollar",
+ icon: { kind: "system", name: "goodDollarLogo" },
+ },
+ {
+ id: "send",
+ routeSlug: "send",
+ label: "Send",
+ icon: { kind: "system", name: "ArrowUpAlt" },
+ },
+ {
+ id: "receive",
+ routeSlug: "receive",
+ label: "Receive",
+ icon: { kind: "system", name: "ArrowDownAlt" },
+ },
+ {
+ id: "swap",
+ routeSlug: "swap",
+ label: "Swap",
+ icon: { kind: "system", name: "Swap" },
+ },
+ {
+ id: "predictions",
+ routeSlug: "predictions",
+ label: "Predictions",
+ icon: { kind: "system", name: "Predictions" },
+ },
+ {
+ id: "walletconnect",
+ routeSlug: "walletconnect",
+ label: "WalletConnect",
+ icon: { kind: "system", name: "walletConnectLogo" },
+ },
+] as const satisfies readonly DashboardAction[]
+
+/**
+ * Widgets join the existing responsive action list after the six core actions.
+ */
+export const widgetDashboardActions = WIDGETS.map(
+ (widget): DashboardAction => ({
+ id: widget.widgetId,
+ widgetId: widget.widgetId,
+ routeSlug: widget.routeSlug,
+ label: widget.displayName,
+ icon: widget.icon,
+ }),
+)
diff --git a/src/widgets/resolveReactWidget.test.ts b/src/widgets/resolveReactWidget.test.ts
new file mode 100644
index 0000000..a771531
--- /dev/null
+++ b/src/widgets/resolveReactWidget.test.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest"
+
+import { resolveReactWidget } from "./resolveReactWidget"
+
+describe("React widget export resolution", () => {
+ it("returns the exact declared component export", () => {
+ const GoodReserveWidget = () => null
+
+ expect(resolveReactWidget({ GoodReserveWidget }, "GoodReserveWidget")).toBe(
+ GoodReserveWidget,
+ )
+ })
+
+ it("rejects a missing or non-component export", () => {
+ expect(() => resolveReactWidget({}, "MissingWidget")).toThrow(
+ "does not export React component MissingWidget",
+ )
+ expect(() =>
+ resolveReactWidget(
+ { GoodReserveWidget: "not-a-component" },
+ "GoodReserveWidget",
+ ),
+ ).toThrow("does not export React component GoodReserveWidget")
+ })
+})
diff --git a/src/widgets/resolveReactWidget.ts b/src/widgets/resolveReactWidget.ts
new file mode 100644
index 0000000..c9d2788
--- /dev/null
+++ b/src/widgets/resolveReactWidget.ts
@@ -0,0 +1,17 @@
+import type { HostedReactWidget } from "./hostTypes"
+
+/**
+ * Resolves the reviewed export name and makes stale registry exports explicit.
+ */
+export const resolveReactWidget = (
+ module: Record,
+ exportName: string,
+): HostedReactWidget => {
+ const exportedComponent = module[exportName]
+ if (typeof exportedComponent !== "function") {
+ throw new Error(
+ `Widget module does not export React component ${exportName}`,
+ )
+ }
+ return exportedComponent as HostedReactWidget
+}
diff --git a/tests-playwright/wallet-flows.e2e.ts b/tests-playwright/wallet-flows.e2e.ts
index 1838649..aa12482 100644
--- a/tests-playwright/wallet-flows.e2e.ts
+++ b/tests-playwright/wallet-flows.e2e.ts
@@ -76,6 +76,12 @@ test("captures the authenticated home balance and responsive action grid", async
await expect(page.getByText("$124.68")).toBeVisible()
const walletActions = page.getByTestId("wallet-actions")
await expect(walletActions).toBeVisible()
+ // The registry-backed dashboard keeps all six core actions in their order.
+ await expect(walletActions.getByRole("link")).toHaveCount(6)
+ await expect(walletActions.getByRole("link").first()).toHaveAttribute(
+ "href",
+ "/en/gooddollar",
+ )
if (testInfo.project.name === "mobile") {
const actionsToggle = page.getByTestId("wallet-actions-toggle")
From fb8e572a2ad811390be2c4f91415b4c874115db8 Mon Sep 17 00:00:00 2001
From: blueogin
Date: Thu, 30 Jul 2026 10:17:26 -0400
Subject: [PATCH 03/11] feat: enhance widget registration and validation
- Added validation for reserved widget routes and empty chain IDs in the widget registry.
- Implemented duplicate Custom Element tag checks during widget registration.
- Updated the AuthenticatedWidgetRoute and WidgetRenderer components to include widgetId as a key for better rendering.
- Enhanced the RestrictedEip1193Provider to support transaction preparation and improved error handling for signing requests.
- Introduced tests for new validation rules and widget registration logic.
---
src/widgets/AuthenticatedWidgetRoute.tsx | 1 +
src/widgets/WidgetRenderer.tsx | 2 +
src/widgets/hosts/ReactWidgetHost.tsx | 2 +
.../hosts/WebComponentWidgetHost.test.ts | 37 ++++
src/widgets/hosts/WebComponentWidgetHost.tsx | 63 +++++-
.../RestrictedEip1193Provider.test.ts | 170 +++++++++++++-
.../provider/RestrictedEip1193Provider.ts | 207 +++++++++++++++---
src/widgets/provider/WidgetProvider.tsx | 48 +++-
src/widgets/registry.test.ts | 24 ++
src/widgets/registry.ts | 26 +++
src/widgets/resolveReactWidget.test.ts | 16 ++
src/widgets/resolveReactWidget.ts | 10 +-
12 files changed, 557 insertions(+), 49 deletions(-)
create mode 100644 src/widgets/hosts/WebComponentWidgetHost.test.ts
diff --git a/src/widgets/AuthenticatedWidgetRoute.tsx b/src/widgets/AuthenticatedWidgetRoute.tsx
index b993ca8..3e202a1 100644
--- a/src/widgets/AuthenticatedWidgetRoute.tsx
+++ b/src/widgets/AuthenticatedWidgetRoute.tsx
@@ -42,6 +42,7 @@ export const AuthenticatedWidgetRoute = ({
return (
diff --git a/src/widgets/WidgetRenderer.tsx b/src/widgets/WidgetRenderer.tsx
index 6922033..a90e558 100644
--- a/src/widgets/WidgetRenderer.tsx
+++ b/src/widgets/WidgetRenderer.tsx
@@ -17,6 +17,7 @@ export const WidgetRenderer = ({
if (resolveWidgetIntegrationMode(widget) === "react") {
return (
{
let isMounted = true
+ setComponent(null)
+ setLoadError(null)
load()
.then((module) => {
diff --git a/src/widgets/hosts/WebComponentWidgetHost.test.ts b/src/widgets/hosts/WebComponentWidgetHost.test.ts
new file mode 100644
index 0000000..3c27612
--- /dev/null
+++ b/src/widgets/hosts/WebComponentWidgetHost.test.ts
@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+import { registerElement } from "./WebComponentWidgetHost"
+
+describe("Custom Element registration", () => {
+ afterEach(() => {
+ vi.restoreAllMocks()
+ vi.unstubAllGlobals()
+ })
+
+ it("registers a tag once and rejects a different loader for the same tag", async () => {
+ const define = vi.fn()
+ const get = vi.fn(() => undefined)
+ vi.stubGlobal("customElements", { define, get })
+
+ const firstLoad = vi.fn(async () => ({
+ register: async (tagName?: string) => {
+ get.mockReturnValue(class {} as CustomElementConstructor)
+ return tagName ?? "gw-widget"
+ },
+ }))
+ const secondLoad = vi.fn(async () => ({
+ register: async (tagName?: string) => tagName ?? "gw-widget",
+ }))
+
+ await expect(registerElement(firstLoad, "gw-widget")).resolves.toBe(
+ "gw-widget",
+ )
+ await expect(registerElement(firstLoad, "gw-widget")).resolves.toBe(
+ "gw-widget",
+ )
+ expect(firstLoad).toHaveBeenCalledTimes(1)
+ await expect(registerElement(secondLoad, "gw-widget")).rejects.toThrow(
+ "already registered",
+ )
+ })
+})
diff --git a/src/widgets/hosts/WebComponentWidgetHost.tsx b/src/widgets/hosts/WebComponentWidgetHost.tsx
index 7917046..bb68a1b 100644
--- a/src/widgets/hosts/WebComponentWidgetHost.tsx
+++ b/src/widgets/hosts/WebComponentWidgetHost.tsx
@@ -14,6 +14,55 @@ import type {
WidgetHostProps,
} from "../hostTypes"
+type TagRegistration = {
+ load: WebComponentWidgetLoader
+ promise: Promise
+}
+
+const registrationCache = new Map()
+
+export const registerElement = (
+ load: WebComponentWidgetLoader,
+ tagName: string,
+): Promise => {
+ const existingDefinition = customElements.get(tagName)
+ const cached = registrationCache.get(tagName)
+ if (cached) {
+ if (cached.load !== load) {
+ return Promise.reject(
+ new Error(`Custom Element tag ${tagName} is already registered`),
+ )
+ }
+ return cached.promise
+ }
+ if (existingDefinition) {
+ return Promise.reject(
+ new Error(`Custom Element tag ${tagName} is already registered`),
+ )
+ }
+
+ const promise = load()
+ .then(async (module) => {
+ const registered = await module.register(tagName)
+ if (registered !== tagName) {
+ throw new Error(
+ `Widget registered ${registered}; expected declared tag ${tagName}`,
+ )
+ }
+ if (!customElements.get(tagName)) {
+ throw new Error(`Widget did not register Custom Element ${tagName}`)
+ }
+ return registered
+ })
+ .catch((error: unknown) => {
+ registrationCache.delete(tagName)
+ throw error
+ })
+
+ registrationCache.set(tagName, { load, promise })
+ return promise
+}
+
/**
* Registers and mounts a widget Custom Element exclusively on the client.
*/
@@ -35,17 +84,12 @@ export const WebComponentWidgetHost = ({
useEffect(() => {
let isMounted = true
+ setRegisteredTagName(null)
+ setLoadError(null)
- // Element classes may depend on HTMLElement at module evaluation time.
- load()
- .then(async (module) => {
- const registered = await module.register(tagName)
+ registerElement(load, tagName)
+ .then((registered) => {
if (!isMounted) return
- if (registered !== tagName) {
- throw new Error(
- `Widget registered ${registered}; expected declared tag ${tagName}`,
- )
- }
setRegisteredTagName(registered)
})
.catch((error: unknown) => {
@@ -66,7 +110,6 @@ export const WebComponentWidgetHost = ({
const element = elementRef.current
if (!element || !registeredTagName) return
- // Object assignment preserves provider identity and prevents HTML leakage.
assignHostedWidgetProperties(element, {
provider,
themeOverrides,
diff --git a/src/widgets/provider/RestrictedEip1193Provider.test.ts b/src/widgets/provider/RestrictedEip1193Provider.test.ts
index 892de54..f0208ec 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.test.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.test.ts
@@ -1,4 +1,7 @@
-import { describe, expect, it, vi } from "vitest"
+import type { TransactionRequest } from "ethers"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import type { EVMSigner } from "@/login"
vi.mock("@/chain/provider/EVM/viemClients", () => ({
getViemClient: vi.fn(),
@@ -34,21 +37,39 @@ const createProvider = (
) => {
const rpcRequest = vi.fn(async () => "0xresult")
const requestWalletApproval = vi.fn(async () => true)
+ const prepareTransaction = vi.fn(
+ async (
+ _chainId: number,
+ _signer: EVMSigner,
+ request: TransactionRequest,
+ ) => ({
+ ...request,
+ nonce: 7,
+ gasLimit: request.gasLimit ?? BigInt(21000),
+ gasPrice: BigInt(1),
+ }),
+ )
return {
provider: new RestrictedEip1193Provider({
signer,
chainIds: [1, 42220],
rpcRequest,
requestWalletApproval,
+ prepareTransaction,
...options,
requiredMethods: options.requiredMethods ?? allTestMethods,
}),
rpcRequest,
requestWalletApproval,
+ prepareTransaction,
}
}
describe("RestrictedEip1193Provider", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ })
+
it("exposes only the active account and forwards reviewed reads", async () => {
const { provider, rpcRequest } = createProvider()
await expect(provider.request({ method: "eth_accounts" })).resolves.toEqual(
@@ -106,16 +127,30 @@ describe("RestrictedEip1193Provider", () => {
})
it("requires account and chain validation plus Wallet approval for transactions", async () => {
- const { provider, requestWalletApproval, rpcRequest } = createProvider()
+ const { provider, requestWalletApproval, prepareTransaction, rpcRequest } =
+ createProvider()
await expect(
provider.request({
method: "eth_sendTransaction",
- params: [{ from: address, chainId: 1, to: address, value: BigInt(1) }],
+ params: [
+ {
+ from: address,
+ chainId: 1,
+ to: address,
+ value: BigInt(1),
+ gas: "0x5208",
+ },
+ ],
}),
).resolves.toBe("0xresult")
expect(requestWalletApproval).toHaveBeenCalledWith(
expect.objectContaining({ method: "eth_sendTransaction", chainId: 1 }),
)
+ expect(prepareTransaction).toHaveBeenCalledWith(
+ 1,
+ signer,
+ expect.objectContaining({ gasLimit: BigInt(21000) }),
+ )
expect(signer.signTransaction).toHaveBeenCalled()
expect(rpcRequest).toHaveBeenCalledWith(1, {
method: "eth_sendRawTransaction",
@@ -156,4 +191,133 @@ describe("RestrictedEip1193Provider", () => {
).rejects.toMatchObject({ code: 4100 })
expect(requestWalletApproval).not.toHaveBeenCalled()
})
+
+ it("signs the transaction snapshot that was presented for approval", async () => {
+ let resolveApproval: ((approved: boolean) => void) | undefined
+ const requestWalletApproval = vi.fn(
+ () =>
+ new Promise((resolve) => {
+ resolveApproval = resolve
+ }),
+ )
+ const { provider, prepareTransaction } = createProvider({
+ requestWalletApproval,
+ })
+ const originalRecipient = "0x2222222222222222222222222222222222222222"
+ const changedRecipient = "0x3333333333333333333333333333333333333333"
+ const transaction = {
+ from: address,
+ chainId: 1,
+ to: originalRecipient,
+ value: BigInt(1),
+ }
+ const pending = provider.request({
+ method: "eth_sendTransaction",
+ params: [transaction],
+ })
+ await vi.waitFor(() => expect(requestWalletApproval).toHaveBeenCalled())
+ transaction.to = changedRecipient
+ resolveApproval?.(true)
+ await expect(pending).resolves.toBe("0xresult")
+ expect(prepareTransaction).toHaveBeenCalledWith(
+ 1,
+ signer,
+ expect.objectContaining({ to: originalRecipient }),
+ )
+ expect(signer.signTransaction).toHaveBeenCalledWith(
+ expect.objectContaining({ to: originalRecipient }),
+ )
+ })
+
+ it("rejects approval when the account or chain changes", async () => {
+ let resolveApproval: ((approved: boolean) => void) | undefined
+ const requestWalletApproval = vi.fn(
+ () =>
+ new Promise((resolve) => {
+ resolveApproval = resolve
+ }),
+ )
+ const { provider } = createProvider({ requestWalletApproval })
+ const pending = provider.request({
+ method: "personal_sign",
+ params: ["message", address],
+ })
+ await vi.waitFor(() => expect(requestWalletApproval).toHaveBeenCalled())
+ provider.updateAccount({
+ ...signer,
+ address: "0x2222222222222222222222222222222222222222",
+ })
+ resolveApproval?.(true)
+ await expect(pending).rejects.toMatchObject({ code: 4100 })
+ expect(signer.signMessage).not.toHaveBeenCalled()
+ })
+
+ it("revokes retained providers and pending approvals", async () => {
+ let resolveApproval: ((approved: boolean) => void) | undefined
+ const requestWalletApproval = vi.fn(
+ () =>
+ new Promise((resolve) => {
+ resolveApproval = resolve
+ }),
+ )
+ const { provider } = createProvider({ requestWalletApproval })
+ const listener = vi.fn()
+ provider.on("accountsChanged", listener)
+ const pending = provider.request({
+ method: "personal_sign",
+ params: ["message", address],
+ })
+ await vi.waitFor(() => expect(requestWalletApproval).toHaveBeenCalled())
+ provider.dispose()
+ resolveApproval?.(true)
+ await expect(pending).rejects.toMatchObject({ code: 4100 })
+ await expect(
+ provider.request({ method: "eth_accounts" }),
+ ).rejects.toMatchObject({ code: 4100 })
+ expect(listener).toHaveBeenCalledWith([])
+ expect(signer.signMessage).not.toHaveBeenCalled()
+ })
+
+ it("rejects conflicting gas fields and same-address signer replacement", async () => {
+ const { provider } = createProvider()
+ await expect(
+ provider.request({
+ method: "eth_sendTransaction",
+ params: [
+ {
+ from: address,
+ chainId: 1,
+ to: address,
+ gas: "0x5208",
+ gasLimit: "0x5209",
+ },
+ ],
+ }),
+ ).rejects.toMatchObject({ code: 4200 })
+
+ let resolveApproval: ((approved: boolean) => void) | undefined
+ const requestWalletApproval = vi.fn(
+ () =>
+ new Promise((resolve) => {
+ resolveApproval = resolve
+ }),
+ )
+ const { provider: signingProvider } = createProvider({
+ requestWalletApproval,
+ })
+ const pending = signingProvider.request({
+ method: "personal_sign",
+ params: ["message", address],
+ })
+ await vi.waitFor(() => expect(requestWalletApproval).toHaveBeenCalled())
+ signingProvider.updateAccount({
+ address,
+ signMessage: vi.fn(async () => "0xother"),
+ signTypedData: vi.fn(async () => "0xtyped"),
+ signTransaction: vi.fn(async () => "0xraw"),
+ })
+ resolveApproval?.(true)
+ await expect(pending).rejects.toMatchObject({ code: 4100 })
+ expect(signer.signMessage).not.toHaveBeenCalled()
+ })
})
diff --git a/src/widgets/provider/RestrictedEip1193Provider.ts b/src/widgets/provider/RestrictedEip1193Provider.ts
index 2e294e8..b939cd7 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.ts
@@ -4,9 +4,12 @@ import type {
TypedDataField,
} from "ethers"
import { getBytes } from "ethers"
+import { copyRequest } from "ethers/providers"
import { getViemClient } from "@/chain/provider/EVM/viemClients"
+import { getEthersProvider } from "@/ethers-utils"
import type { EVMSigner } from "@/login"
+import { WalletWrapper } from "@/sections/WalletConnect/utils/WalletWrapper"
import {
WIDGET_EVM_CHAIN_IDS,
@@ -47,6 +50,11 @@ export type RestrictedProviderOptions = {
* default leaves every signing method disabled until that UI is supplied.
*/
requestWalletApproval?: (request: WalletApprovalRequest) => Promise
+ prepareTransaction?: (
+ chainId: number,
+ signer: EVMSigner,
+ request: TransactionRequest,
+ ) => Promise
rpcRequest?: (chainId: number, request: ProviderRequest) => Promise
}
@@ -63,6 +71,16 @@ const asChainId = (value: unknown): number => {
const addressesMatch = (left: unknown, right: string): boolean =>
typeof left === "string" && left.toLowerCase() === right.toLowerCase()
+const approvalTransaction = (
+ request: TransactionRequest,
+): Record =>
+ Object.fromEntries(
+ Object.entries(request).map(([key, value]) => [
+ key,
+ typeof value === "bigint" ? `0x${value.toString(16)}` : value,
+ ]),
+ )
+
const normalizeError = (error: unknown): WidgetProviderError => {
if (error instanceof WidgetProviderError) return error
const message =
@@ -86,8 +104,13 @@ export class RestrictedEip1193Provider {
readonly #requestWalletApproval: NonNullable<
RestrictedProviderOptions["requestWalletApproval"]
>
+ readonly #prepareTransaction: NonNullable<
+ RestrictedProviderOptions["prepareTransaction"]
+ >
readonly #rpcRequest: NonNullable
+ #approvalPending = false
#chainId: number
+ #revoked = false
#signer: EVMSigner
constructor(options: RestrictedProviderOptions) {
@@ -124,6 +147,15 @@ export class RestrictedEip1193Provider {
// Signing is disabled unless a Wallet-owned confirmation surface opts in.
this.#requestWalletApproval =
options.requestWalletApproval ?? (async () => false)
+ this.#prepareTransaction =
+ options.prepareTransaction ??
+ (async (chainId, signer, request) => {
+ const connectedSigner = new WalletWrapper(
+ signer,
+ getEthersProvider(chainId),
+ )
+ return await connectedSigner.populateTransaction(request)
+ })
this.#rpcRequest =
options.rpcRequest ??
(async (chainId, request) => {
@@ -142,6 +174,10 @@ export class RestrictedEip1193Provider {
return [...this.#allowedMethods]
}
+ get isRevoked(): boolean {
+ return this.#revoked
+ }
+
on(
event: "accountsChanged" | "chainChanged",
listener: (...args: unknown[]) => void,
@@ -164,12 +200,21 @@ export class RestrictedEip1193Provider {
* Session updates retain the facade while notifying a widget of account loss.
*/
updateAccount(signer: EVMSigner): void {
+ this.#assertActive()
const accountChanged = !addressesMatch(signer.address, this.#signer.address)
this.#signer = signer
if (accountChanged) this.#emit("accountsChanged", [signer.address])
}
+ dispose(): void {
+ if (this.#revoked) return
+ this.#revoked = true
+ this.#emit("accountsChanged", [])
+ this.#listeners.clear()
+ }
+
async request(request: ProviderRequest): Promise {
+ this.#assertActive()
if (!WIDGET_PROVIDER_METHODS.has(request.method)) {
throw new WidgetProviderError(
4200,
@@ -201,7 +246,9 @@ export class RestrictedEip1193Provider {
return await this.#sendTransaction(params)
default:
if (WIDGET_READ_METHODS.has(request.method)) {
- return await this.#rpcRequest(this.#chainId, request)
+ const result = await this.#rpcRequest(this.#chainId, request)
+ this.#assertActive()
+ return result
}
throw new WidgetProviderError(4200, "Unsupported widget request")
}
@@ -214,30 +261,79 @@ export class RestrictedEip1193Provider {
for (const listener of this.#listeners.get(event) ?? []) listener(value)
}
- #assertAccount(account: unknown): void {
+ #assertActive(): void {
+ if (this.#revoked) {
+ throw new WidgetProviderError(4100, "The widget provider was revoked")
+ }
+ }
+
+ #captureSigningContext(account: unknown): {
+ signer: EVMSigner
+ account: string
+ chainId: number
+ } {
+ this.#assertActive()
if (!addressesMatch(account, this.#signer.address)) {
throw new WidgetProviderError(
4100,
"The signing account does not match the active GoodWallet session",
)
}
+ return {
+ signer: this.#signer,
+ account: this.#signer.address,
+ chainId: this.#chainId,
+ }
+ }
+
+ #assertSigningContext(context: {
+ signer: EVMSigner
+ account: string
+ chainId: number
+ }): void {
+ this.#assertActive()
+ if (
+ this.#signer !== context.signer ||
+ !addressesMatch(this.#signer.address, context.account) ||
+ this.#chainId !== context.chainId
+ ) {
+ throw new WidgetProviderError(
+ 4100,
+ "The active wallet account or chain changed during approval",
+ )
+ }
}
async #requestSigningApproval(
method: string,
params: readonly unknown[],
+ context: {
+ signer: EVMSigner
+ account: string
+ chainId: number
+ },
): Promise {
- const approved = await this.#requestWalletApproval({
- method,
- params,
- account: this.#signer.address,
- chainId: this.#chainId,
- })
- if (!approved) {
- throw new WidgetProviderError(
- 4001,
- "GoodWallet did not approve the signing request",
- )
+ if (this.#approvalPending) {
+ throw new WidgetProviderError(4200, "Another widget approval is pending")
+ }
+ this.#assertSigningContext(context)
+ this.#approvalPending = true
+ try {
+ const approved = await this.#requestWalletApproval({
+ method,
+ params,
+ account: context.account,
+ chainId: context.chainId,
+ })
+ this.#assertSigningContext(context)
+ if (!approved) {
+ throw new WidgetProviderError(
+ 4001,
+ "GoodWallet did not approve the signing request",
+ )
+ }
+ } finally {
+ this.#approvalPending = false
}
}
@@ -250,7 +346,7 @@ export class RestrictedEip1193Provider {
const chainId = asChainId(rawChainId)
if (!this.#allowedChainIds.has(chainId)) {
throw new WidgetProviderError(
- 4901,
+ 4100,
`Chain ${chainId} is not allowed for this widget`,
)
}
@@ -263,19 +359,21 @@ export class RestrictedEip1193Provider {
async #signMessage(params: readonly unknown[]): Promise {
const [message, account] = params
- this.#assertAccount(account)
if (typeof message !== "string") {
throw new WidgetProviderError(4200, "personal_sign requires a message")
}
- await this.#requestSigningApproval("personal_sign", params)
- return await this.#signer.signMessage(
+ const context = this.#captureSigningContext(account)
+ const approvalParams = [message, context.account] as const
+ await this.#requestSigningApproval("personal_sign", approvalParams, context)
+ const signature = await context.signer.signMessage(
/^0x[0-9a-f]*$/i.test(message) ? getBytes(message) : message,
)
+ this.#assertSigningContext(context)
+ return signature
}
async #signTypedData(params: readonly unknown[]): Promise {
const [account, rawData] = params
- this.#assertAccount(account)
if (typeof rawData !== "string") {
throw new WidgetProviderError(
4200,
@@ -290,45 +388,94 @@ export class RestrictedEip1193Provider {
if (!data.domain || !data.types || !data.message) {
throw new WidgetProviderError(4200, "Invalid EIP-712 typed data")
}
+ const context = this.#captureSigningContext(account)
const { EIP712Domain: _domainType, ...types } = data.types
if (
data.domain.chainId !== undefined &&
- Number(data.domain.chainId) !== this.#chainId
+ Number(data.domain.chainId) !== context.chainId
) {
throw new WidgetProviderError(
4100,
"Typed-data chain does not match the active widget chain",
)
}
- await this.#requestSigningApproval("eth_signTypedData_v4", params)
- return await this.#signer.signTypedData(data.domain, types, data.message)
+ const approvalParams = [context.account, rawData] as const
+ await this.#requestSigningApproval(
+ "eth_signTypedData_v4",
+ approvalParams,
+ context,
+ )
+ const signature = await context.signer.signTypedData(
+ data.domain,
+ types,
+ data.message,
+ )
+ this.#assertSigningContext(context)
+ return signature
}
async #sendTransaction(params: readonly unknown[]): Promise {
const transaction = params[0]
- if (!transaction || typeof transaction !== "object") {
+ if (
+ !transaction ||
+ typeof transaction !== "object" ||
+ Array.isArray(transaction)
+ ) {
throw new WidgetProviderError(4200, "A transaction object is required")
}
- const request = transaction as TransactionRequest & {
+ const rawRequest = transaction as TransactionRequest & {
from?: string
+ gas?: string | number | bigint
chainId?: string | number
}
- this.#assertAccount(request.from)
+ const context = this.#captureSigningContext(rawRequest.from)
if (
- request.chainId !== undefined &&
- Number(request.chainId) !== this.#chainId
+ rawRequest.chainId !== undefined &&
+ Number(rawRequest.chainId) !== context.chainId
) {
throw new WidgetProviderError(
4100,
"Transaction chain does not match the active widget chain",
)
}
- await this.#requestSigningApproval("eth_sendTransaction", params)
- const { from: _from, ...signableRequest } = request
- const rawTransaction = await this.#signer.signTransaction(signableRequest)
- return await this.#rpcRequest(this.#chainId, {
+ if (
+ rawRequest.gas !== undefined &&
+ rawRequest.gasLimit !== undefined &&
+ BigInt(rawRequest.gas) !== BigInt(rawRequest.gasLimit)
+ ) {
+ throw new WidgetProviderError(
+ 4200,
+ "Transaction gas and gasLimit must match",
+ )
+ }
+ const copiedRequest = copyRequest({
+ ...rawRequest,
+ chainId: context.chainId,
+ gasLimit: rawRequest.gasLimit ?? rawRequest.gas,
+ })
+ const { from: _from, ...unsignedRequest } = copiedRequest
+ const populatedRequest = copyRequest(
+ await this.#prepareTransaction(
+ context.chainId,
+ context.signer,
+ unsignedRequest,
+ ),
+ )
+ this.#assertSigningContext(context)
+ const approvalParams = [approvalTransaction(populatedRequest)] as const
+ await this.#requestSigningApproval(
+ "eth_sendTransaction",
+ approvalParams,
+ context,
+ )
+ const rawTransaction =
+ await context.signer.signTransaction(populatedRequest)
+ this.#assertSigningContext(context)
+ const result = await this.#rpcRequest(context.chainId, {
method: "eth_sendRawTransaction",
params: [rawTransaction],
})
+ this.#assertSigningContext(context)
+ return result
}
}
diff --git a/src/widgets/provider/WidgetProvider.tsx b/src/widgets/provider/WidgetProvider.tsx
index f807577..6c9c0e7 100644
--- a/src/widgets/provider/WidgetProvider.tsx
+++ b/src/widgets/provider/WidgetProvider.tsx
@@ -6,16 +6,44 @@ import {
useContext,
useEffect,
useMemo,
+ useRef,
} from "react"
import { useSessionContext } from "@/login/hooks/context"
+import { openWalletConnectDialog } from "@/sections/WalletConnect/store/walletConnectDialogStore"
-import { RestrictedEip1193Provider } from "./RestrictedEip1193Provider"
+import {
+ RestrictedEip1193Provider,
+ type WalletApprovalRequest,
+} from "./RestrictedEip1193Provider"
const WidgetProviderContext = createContext(
null,
)
+const requestWalletApproval = async (
+ request: WalletApprovalRequest,
+): Promise => {
+ const status = await openWalletConnectDialog({
+ type: "generic",
+ title: "Approve widget request",
+ bodyText: JSON.stringify(
+ {
+ method: request.method,
+ account: request.account,
+ chainId: request.chainId,
+ params: request.params,
+ },
+ (_key, value: unknown) =>
+ typeof value === "bigint" ? `0x${value.toString(16)}` : value,
+ 2,
+ ),
+ acceptBtnText: "Approve",
+ rejectBtnText: "Reject",
+ })
+ return status === "accepted"
+}
+
/**
* This is the sole bridge from an authenticated session into widget code.
*/
@@ -30,6 +58,7 @@ export const WidgetProvider = ({
}) => {
const { signer } = useSessionContext()
const evmSigner = signer?.EVM
+ const liveProviderRef = useRef(null)
const provider = useMemo(
() =>
evmSigner
@@ -37,16 +66,27 @@ export const WidgetProvider = ({
signer: evmSigner,
chainIds,
requiredMethods,
+ requestWalletApproval,
})
: null,
[evmSigner, chainIds, requiredMethods],
)
useEffect(() => {
- if (provider && evmSigner) provider.updateAccount(evmSigner)
- }, [evmSigner, provider])
+ liveProviderRef.current = provider
+ return () => {
+ const disposedProvider = provider
+ if (liveProviderRef.current === disposedProvider) {
+ liveProviderRef.current = null
+ }
+ queueMicrotask(() => {
+ if (liveProviderRef.current === disposedProvider) return
+ disposedProvider?.dispose()
+ })
+ }
+ }, [provider])
- if (!provider) return null
+ if (!provider || !evmSigner) return null
return (
{children}
diff --git a/src/widgets/registry.test.ts b/src/widgets/registry.test.ts
index e2b2da5..ac74e12 100644
--- a/src/widgets/registry.test.ts
+++ b/src/widgets/registry.test.ts
@@ -82,6 +82,30 @@ describe("widget registry", () => {
).toThrow("unsupported methods")
})
+ it("rejects reserved routes, empty chains, and duplicate Custom Element tags", () => {
+ expect(() =>
+ createWidgetRegistry([{ ...widget, routeSlug: "send" }]),
+ ).toThrow("reserved route")
+ expect(() =>
+ createWidgetRegistry([
+ {
+ ...widget,
+ providerPolicy: { ...widget.providerPolicy, chainIds: [] },
+ },
+ ]),
+ ).toThrow("at least one chain")
+ expect(() =>
+ createWidgetRegistry([
+ widget,
+ {
+ ...widget,
+ widgetId: "goodwidget.other",
+ routeSlug: "other",
+ },
+ ]),
+ ).toThrow("Duplicate widget Custom Element tag")
+ })
+
it("keeps the six reviewed core actions ahead of widget actions", () => {
expect(coreDashboardActions.map(({ id }) => id)).toEqual([
"gooddollar",
diff --git a/src/widgets/registry.ts b/src/widgets/registry.ts
index a5e3730..664e9f3 100644
--- a/src/widgets/registry.ts
+++ b/src/widgets/registry.ts
@@ -64,6 +64,17 @@ export const resolveWidgetIntegrationMode = (
const EXACT_PACKAGE_VERSION = /^\d+\.\d+\.\d+$/
const ROUTE_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+const RESERVED_WIDGET_ROUTES = new Set([
+ "gooddollar",
+ "send",
+ "receive",
+ "swap",
+ "predictions",
+ "walletconnect",
+ "options",
+ "promo",
+ "qr",
+])
/**
* Validates every security-sensitive registry field before it becomes routable.
@@ -77,6 +88,14 @@ const validateWidget = (widget: RegisteredWidget): void => {
if (!ROUTE_SLUG.test(widget.routeSlug)) {
throw new Error(`Widget ${widget.widgetId} has an invalid route slug`)
}
+ if (RESERVED_WIDGET_ROUTES.has(widget.routeSlug)) {
+ throw new Error(
+ `Widget ${widget.widgetId} uses a reserved route: ${widget.routeSlug}`,
+ )
+ }
+ if (widget.providerPolicy.chainIds.length === 0) {
+ throw new Error(`Widget ${widget.widgetId} requires at least one chain`)
+ }
const unsupportedChains = widget.providerPolicy.chainIds.filter(
(chainId) => !WIDGET_EVM_CHAIN_IDS.has(chainId),
)
@@ -109,6 +128,7 @@ export const createWidgetRegistry = (
): ReadonlyMap => {
const registry = new Map()
const routes = new Set()
+ const tags = new Set()
for (const widget of widgets) {
validateWidget(widget)
@@ -118,8 +138,14 @@ export const createWidgetRegistry = (
if (routes.has(widget.routeSlug)) {
throw new Error(`Duplicate widget route: ${widget.routeSlug}`)
}
+ if (tags.has(widget.entries.webComponent.tagName)) {
+ throw new Error(
+ `Duplicate widget Custom Element tag: ${widget.entries.webComponent.tagName}`,
+ )
+ }
registry.set(widget.widgetId, widget)
routes.add(widget.routeSlug)
+ tags.add(widget.entries.webComponent.tagName)
}
return registry
diff --git a/src/widgets/resolveReactWidget.test.ts b/src/widgets/resolveReactWidget.test.ts
index a771531..6269c25 100644
--- a/src/widgets/resolveReactWidget.test.ts
+++ b/src/widgets/resolveReactWidget.test.ts
@@ -11,6 +11,22 @@ describe("React widget export resolution", () => {
)
})
+ it("accepts memoized and forwarded React component objects", () => {
+ const MemoWidget = {
+ $$typeof: Symbol.for("react.memo"),
+ type: () => null,
+ }
+ const ForwardWidget = {
+ $$typeof: Symbol.for("react.forward_ref"),
+ render: () => null,
+ }
+
+ expect(resolveReactWidget({ MemoWidget }, "MemoWidget")).toBe(MemoWidget)
+ expect(resolveReactWidget({ ForwardWidget }, "ForwardWidget")).toBe(
+ ForwardWidget,
+ )
+ })
+
it("rejects a missing or non-component export", () => {
expect(() => resolveReactWidget({}, "MissingWidget")).toThrow(
"does not export React component MissingWidget",
diff --git a/src/widgets/resolveReactWidget.ts b/src/widgets/resolveReactWidget.ts
index c9d2788..836d8fb 100644
--- a/src/widgets/resolveReactWidget.ts
+++ b/src/widgets/resolveReactWidget.ts
@@ -1,5 +1,11 @@
import type { HostedReactWidget } from "./hostTypes"
+const isReactComponent = (value: unknown): value is HostedReactWidget => {
+ if (typeof value === "function") return true
+ if (!value || typeof value !== "object") return false
+ return typeof (value as { $$typeof?: unknown }).$$typeof === "symbol"
+}
+
/**
* Resolves the reviewed export name and makes stale registry exports explicit.
*/
@@ -8,10 +14,10 @@ export const resolveReactWidget = (
exportName: string,
): HostedReactWidget => {
const exportedComponent = module[exportName]
- if (typeof exportedComponent !== "function") {
+ if (!isReactComponent(exportedComponent)) {
throw new Error(
`Widget module does not export React component ${exportName}`,
)
}
- return exportedComponent as HostedReactWidget
+ return exportedComponent
}
From 2ce2810581bc4ce9cf73dd9dd3115845f1688121 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 30 Jul 2026 14:24:21 +0000
Subject: [PATCH 04/11] Serialize wallet approval dialogs
---
.../store/walletConnectDialogStore.test.ts | 27 +++++++++++++
.../store/walletConnectDialogStore.ts | 40 ++++++++++++++-----
2 files changed, 57 insertions(+), 10 deletions(-)
create mode 100644 src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
diff --git a/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts b/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
new file mode 100644
index 0000000..dffa203
--- /dev/null
+++ b/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
@@ -0,0 +1,27 @@
+import {
+ openWalletConnectDialog,
+ walletConnectDialogStore,
+} from "./walletConnectDialogStore"
+
+const dialog = (title: string) => ({
+ type: "generic" as const,
+ title,
+ bodyText: title,
+ acceptBtnText: "Approve",
+})
+
+describe("openWalletConnectDialog", () => {
+ it("keeps concurrent approvals bound to their own dialogs", async () => {
+ const first = openWalletConnectDialog(dialog("First"))
+ const second = openWalletConnectDialog(dialog("Second"))
+
+ expect(walletConnectDialogStore.dialog.title).toBe("First")
+
+ walletConnectDialogStore.status = "accepted"
+ await expect(first).resolves.toBe("accepted")
+ expect(walletConnectDialogStore.dialog.title).toBe("Second")
+
+ walletConnectDialogStore.status = "rejected"
+ await expect(second).resolves.toBe("rejected")
+ })
+})
diff --git a/src/sections/WalletConnect/store/walletConnectDialogStore.ts b/src/sections/WalletConnect/store/walletConnectDialogStore.ts
index ef6c220..7914973 100644
--- a/src/sections/WalletConnect/store/walletConnectDialogStore.ts
+++ b/src/sections/WalletConnect/store/walletConnectDialogStore.ts
@@ -44,22 +44,42 @@ export const walletConnectDialogStore = proxy<{
exiting: boolean
}>()
-export const openWalletConnectDialog = async (args: WalletConnectDialog) => {
- walletConnectDialogStore.dialog = args
+type QueuedDialog = {
+ args: WalletConnectDialog
+ resolve: (status: WalletConnectDialogStatus) => void
+}
+
+const dialogQueue: QueuedDialog[] = []
+let dialogOpen = false
+
+const openNextDialog = (): void => {
+ if (dialogOpen) return
+ const queuedDialog = dialogQueue.shift()
+ if (!queuedDialog) return
+
+ dialogOpen = true
+ walletConnectDialogStore.dialog = queuedDialog.args
walletConnectDialogStore.status = "pending"
walletConnectDialogStore.exiting = false
- await new Promise((resolve) => {
- subscribe(walletConnectDialogStore, () => {
- if (walletConnectDialogStore.status !== "pending") {
- resolve(null)
- }
- })
+ const unsubscribe = subscribe(walletConnectDialogStore, () => {
+ if (walletConnectDialogStore.status === "pending") return
+ const status = walletConnectDialogStore.status
+ unsubscribe()
+ dialogOpen = false
+ queuedDialog.resolve(status)
+ openNextDialog()
})
-
- return walletConnectDialogStore.status as WalletConnectDialogStatus
}
+export const openWalletConnectDialog = (
+ args: WalletConnectDialog,
+): Promise =>
+ new Promise((resolve) => {
+ dialogQueue.push({ args, resolve })
+ openNextDialog()
+ })
+
export const updateWalletConnectDialogStatus = async (
status: WalletConnectDialogStatus,
) => {
From 88f19bf747caae2cf9aa8bf07878f3f84e837572 Mon Sep 17 00:00:00 2001
From: blueogin
Date: Thu, 30 Jul 2026 10:50:26 -0400
Subject: [PATCH 05/11] refactor: clean up comments and improve widget
registration structure
- Removed outdated comments from various files to enhance code clarity.
- Updated the widget registration logic to streamline the integration of React and web component entries.
- Adjusted tests to reflect changes in widget registration and validation processes.
---
.../(bottomsheet)/[widgetRoute]/page.tsx | 4 --
.../Form/RoundButton/RoundButton.tsx | 2 -
.../Home/components/WalletSection.tsx | 2 -
.../store/walletConnectDialogStore.test.ts | 6 +-
src/widgets/AuthenticatedWidgetRoute.tsx | 7 ---
src/widgets/WidgetRenderer.tsx | 17 ++----
src/widgets/hostProperties.ts | 6 --
src/widgets/hostTypes.ts | 16 ------
src/widgets/hosts/ReactWidgetHost.tsx | 5 --
.../hosts/WebComponentWidgetHost.test.ts | 4 +-
src/widgets/hosts/WebComponentWidgetHost.tsx | 3 -
.../RestrictedEip1193Provider.test.ts | 50 +----------------
.../provider/RestrictedEip1193Provider.ts | 22 +-------
src/widgets/provider/WidgetProvider.tsx | 3 -
src/widgets/provider/policy.ts | 4 --
src/widgets/registry.test.ts | 27 +++++----
src/widgets/registry.ts | 55 +++++++------------
src/widgets/resolveReactWidget.ts | 3 -
tests-playwright/wallet-flows.e2e.ts | 1 -
19 files changed, 49 insertions(+), 188 deletions(-)
diff --git a/src/app/[locale]/@home/(home)/(bottomsheet)/[widgetRoute]/page.tsx b/src/app/[locale]/@home/(home)/(bottomsheet)/[widgetRoute]/page.tsx
index dfe5a0b..2e68b36 100644
--- a/src/app/[locale]/@home/(home)/(bottomsheet)/[widgetRoute]/page.tsx
+++ b/src/app/[locale]/@home/(home)/(bottomsheet)/[widgetRoute]/page.tsx
@@ -3,10 +3,6 @@ import { notFound } from "next/navigation"
import { AuthenticatedWidgetRoute } from "@/widgets/AuthenticatedWidgetRoute"
import { getWidgetByRoute } from "@/widgets/registry"
-/**
- * Static core routes take precedence; this fallback can mount only a reviewed
- * registry route and treats every other unknown bottom-sheet URL as not found.
- */
export default async function WidgetRoutePage({
params,
}: {
diff --git a/src/components/Form/RoundButton/RoundButton.tsx b/src/components/Form/RoundButton/RoundButton.tsx
index cc0ab6d..afdaecd 100644
--- a/src/components/Form/RoundButton/RoundButton.tsx
+++ b/src/components/Form/RoundButton/RoundButton.tsx
@@ -7,9 +7,7 @@ import { Icon, type IconName } from "ui"
export type RoundButtonProps = {
onClick?: () => void
buttonType?: RoundButtonType
- /** Registry actions may use a system icon without adding a legacy button type. */
icon?: IconName
- /** Registry actions may use a reviewed local asset without serializing it. */
iconElement?: ReactNode
text?: string
fill?: boolean
diff --git a/src/sections/Home/components/WalletSection.tsx b/src/sections/Home/components/WalletSection.tsx
index f89b509..d3eb5fd 100644
--- a/src/sections/Home/components/WalletSection.tsx
+++ b/src/sections/Home/components/WalletSection.tsx
@@ -196,8 +196,6 @@ export default function WalletSection({
predictions: homeTranslations.predictions,
walletconnect: homeTranslations.walletConnect,
}
- // Widgets append to the existing grid, allowing the current responsive
- // collapse control to keep owning the More behavior and core ordering.
const dashboardActions = [...coreDashboardActions, ...widgetDashboardActions]
return (
diff --git a/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts b/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
index dffa203..b12e190 100644
--- a/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
+++ b/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
@@ -1,3 +1,5 @@
+import { describe, expect, it } from "vitest"
+
import {
openWalletConnectDialog,
walletConnectDialogStore,
@@ -15,11 +17,11 @@ describe("openWalletConnectDialog", () => {
const first = openWalletConnectDialog(dialog("First"))
const second = openWalletConnectDialog(dialog("Second"))
- expect(walletConnectDialogStore.dialog.title).toBe("First")
+ expect(walletConnectDialogStore.dialog).toMatchObject({ title: "First" })
walletConnectDialogStore.status = "accepted"
await expect(first).resolves.toBe("accepted")
- expect(walletConnectDialogStore.dialog.title).toBe("Second")
+ expect(walletConnectDialogStore.dialog).toMatchObject({ title: "Second" })
walletConnectDialogStore.status = "rejected"
await expect(second).resolves.toBe("rejected")
diff --git a/src/widgets/AuthenticatedWidgetRoute.tsx b/src/widgets/AuthenticatedWidgetRoute.tsx
index 3e202a1..583d32e 100644
--- a/src/widgets/AuthenticatedWidgetRoute.tsx
+++ b/src/widgets/AuthenticatedWidgetRoute.tsx
@@ -11,9 +11,6 @@ import { useWidgetProvider, WidgetProvider } from "./provider/WidgetProvider"
import { type RegisteredWidget, widgetRegistry } from "./registry"
import { WidgetRenderer } from "./WidgetRenderer"
-/**
- * Requires an authenticated wallet session before any widget package is loaded.
- */
export const AuthenticatedWidgetRoute = ({
widgetId,
themeOverrides,
@@ -42,7 +39,6 @@ export const AuthenticatedWidgetRoute = ({
return (
@@ -55,9 +51,6 @@ export const AuthenticatedWidgetRoute = ({
)
}
-/**
- * The provider capability enters the renderer only after authentication.
- */
const MountedWidget = ({
widget,
themeOverrides,
diff --git a/src/widgets/WidgetRenderer.tsx b/src/widgets/WidgetRenderer.tsx
index a90e558..c1c61a4 100644
--- a/src/widgets/WidgetRenderer.tsx
+++ b/src/widgets/WidgetRenderer.tsx
@@ -3,23 +3,19 @@
import { ReactWidgetHost } from "./hosts/ReactWidgetHost"
import { WebComponentWidgetHost } from "./hosts/WebComponentWidgetHost"
import type { WidgetHostProps } from "./hostTypes"
-import { type RegisteredWidget, resolveWidgetIntegrationMode } from "./registry"
+import type { RegisteredWidget } from "./registry"
-/**
- * This is the sole integration-mode decision point for every widget route.
- */
export const WidgetRenderer = ({
widget,
...hostProps
}: WidgetHostProps & {
widget: RegisteredWidget
}) => {
- if (resolveWidgetIntegrationMode(widget) === "react") {
+ if (widget.integrationMode === "react") {
return (
)
@@ -27,9 +23,8 @@ export const WidgetRenderer = ({
return (
)
diff --git a/src/widgets/hostProperties.ts b/src/widgets/hostProperties.ts
index bf8214b..c8542a5 100644
--- a/src/widgets/hostProperties.ts
+++ b/src/widgets/hostProperties.ts
@@ -1,8 +1,5 @@
import type { HostedWidgetElement, WidgetHostProps } from "./hostTypes"
-/**
- * Hands the non-serializable wallet capability to the mounted Custom Element.
- */
export const assignHostedWidgetProperties = (
element: HostedWidgetElement,
{ provider, themeOverrides, config }: WidgetHostProps,
@@ -12,9 +9,6 @@ export const assignHostedWidgetProperties = (
element.config = config
}
-/**
- * Removes wallet-owned references before a detached element can retain them.
- */
export const clearHostedWidgetProperties = (
element: HostedWidgetElement,
): void => {
diff --git a/src/widgets/hostTypes.ts b/src/widgets/hostTypes.ts
index b0bd7ba..0c162e3 100644
--- a/src/widgets/hostTypes.ts
+++ b/src/widgets/hostTypes.ts
@@ -2,36 +2,20 @@ import type { ComponentType } from "react"
import type { RestrictedEip1193Provider } from "./provider/RestrictedEip1193Provider"
-/**
- * This is the complete wallet-to-widget contract for both host implementations.
- * Widgets do not receive a signer, seed, RPC client, or wallet session object.
- */
export type WidgetHostProps = {
provider: RestrictedEip1193Provider
themeOverrides?: Record
config?: Record
}
-/**
- * Registry loaders deliberately return an untyped module because independently
- * released widgets are normalized by the host before they are rendered.
- */
export type ReactWidgetLoader = () => Promise>
export type HostedReactWidget = ComponentType
-/**
- * The element module must register its declared tag only after the host mounts
- * in the browser, avoiding Custom Element evaluation during server rendering.
- */
export type WebComponentWidgetLoader = () => Promise<{
register: (tagName?: string) => string | Promise
}>
-/**
- * Widget values are object properties, rather than HTML attributes, so the
- * restricted provider never appears in serialized markup.
- */
export type HostedWidgetElement = HTMLElement & {
provider: RestrictedEip1193Provider | null
themeOverrides?: Record
diff --git a/src/widgets/hosts/ReactWidgetHost.tsx b/src/widgets/hosts/ReactWidgetHost.tsx
index 6ba2646..a57829b 100644
--- a/src/widgets/hosts/ReactWidgetHost.tsx
+++ b/src/widgets/hosts/ReactWidgetHost.tsx
@@ -11,10 +11,6 @@ import type {
} from "../hostTypes"
import { resolveReactWidget } from "../resolveReactWidget"
-/**
- * Loads a reviewed React entry only after this bottom-sheet route reaches the
- * browser and passes it the same limited contract as Custom Elements receive.
- */
export const ReactWidgetHost = ({
load,
exportName,
@@ -35,7 +31,6 @@ export const ReactWidgetHost = ({
.then((module) => {
if (!isMounted) return
const exportedComponent = resolveReactWidget(module, exportName)
- // Functions are React state updaters, so keep the component wrapped.
setComponent(() => exportedComponent)
})
.catch((error: unknown) => {
diff --git a/src/widgets/hosts/WebComponentWidgetHost.test.ts b/src/widgets/hosts/WebComponentWidgetHost.test.ts
index 3c27612..f382bf5 100644
--- a/src/widgets/hosts/WebComponentWidgetHost.test.ts
+++ b/src/widgets/hosts/WebComponentWidgetHost.test.ts
@@ -10,7 +10,9 @@ describe("Custom Element registration", () => {
it("registers a tag once and rejects a different loader for the same tag", async () => {
const define = vi.fn()
- const get = vi.fn(() => undefined)
+ const get = vi.fn<() => CustomElementConstructor | undefined>(
+ () => undefined,
+ )
vi.stubGlobal("customElements", { define, get })
const firstLoad = vi.fn(async () => ({
diff --git a/src/widgets/hosts/WebComponentWidgetHost.tsx b/src/widgets/hosts/WebComponentWidgetHost.tsx
index bb68a1b..4074de5 100644
--- a/src/widgets/hosts/WebComponentWidgetHost.tsx
+++ b/src/widgets/hosts/WebComponentWidgetHost.tsx
@@ -63,9 +63,6 @@ export const registerElement = (
return promise
}
-/**
- * Registers and mounts a widget Custom Element exclusively on the client.
- */
export const WebComponentWidgetHost = ({
load,
tagName,
diff --git a/src/widgets/provider/RestrictedEip1193Provider.test.ts b/src/widgets/provider/RestrictedEip1193Provider.test.ts
index f0208ec..d35a138 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.test.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.test.ts
@@ -229,29 +229,6 @@ describe("RestrictedEip1193Provider", () => {
)
})
- it("rejects approval when the account or chain changes", async () => {
- let resolveApproval: ((approved: boolean) => void) | undefined
- const requestWalletApproval = vi.fn(
- () =>
- new Promise((resolve) => {
- resolveApproval = resolve
- }),
- )
- const { provider } = createProvider({ requestWalletApproval })
- const pending = provider.request({
- method: "personal_sign",
- params: ["message", address],
- })
- await vi.waitFor(() => expect(requestWalletApproval).toHaveBeenCalled())
- provider.updateAccount({
- ...signer,
- address: "0x2222222222222222222222222222222222222222",
- })
- resolveApproval?.(true)
- await expect(pending).rejects.toMatchObject({ code: 4100 })
- expect(signer.signMessage).not.toHaveBeenCalled()
- })
-
it("revokes retained providers and pending approvals", async () => {
let resolveApproval: ((approved: boolean) => void) | undefined
const requestWalletApproval = vi.fn(
@@ -278,7 +255,7 @@ describe("RestrictedEip1193Provider", () => {
expect(signer.signMessage).not.toHaveBeenCalled()
})
- it("rejects conflicting gas fields and same-address signer replacement", async () => {
+ it("rejects conflicting gas fields", async () => {
const { provider } = createProvider()
await expect(
provider.request({
@@ -294,30 +271,5 @@ describe("RestrictedEip1193Provider", () => {
],
}),
).rejects.toMatchObject({ code: 4200 })
-
- let resolveApproval: ((approved: boolean) => void) | undefined
- const requestWalletApproval = vi.fn(
- () =>
- new Promise((resolve) => {
- resolveApproval = resolve
- }),
- )
- const { provider: signingProvider } = createProvider({
- requestWalletApproval,
- })
- const pending = signingProvider.request({
- method: "personal_sign",
- params: ["message", address],
- })
- await vi.waitFor(() => expect(requestWalletApproval).toHaveBeenCalled())
- signingProvider.updateAccount({
- address,
- signMessage: vi.fn(async () => "0xother"),
- signTypedData: vi.fn(async () => "0xtyped"),
- signTransaction: vi.fn(async () => "0xraw"),
- })
- resolveApproval?.(true)
- await expect(pending).rejects.toMatchObject({ code: 4100 })
- expect(signer.signMessage).not.toHaveBeenCalled()
})
})
diff --git a/src/widgets/provider/RestrictedEip1193Provider.ts b/src/widgets/provider/RestrictedEip1193Provider.ts
index b939cd7..058085b 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.ts
@@ -45,10 +45,6 @@ export type RestrictedProviderOptions = {
chainIds: readonly number[]
requiredMethods: readonly string[]
initialChainId?: number
- /**
- * This callback belongs to GoodWallet UI, never to the widget. Its secure
- * default leaves every signing method disabled until that UI is supplied.
- */
requestWalletApproval?: (request: WalletApprovalRequest) => Promise
prepareTransaction?: (
chainId: number,
@@ -89,11 +85,6 @@ const normalizeError = (error: unknown): WidgetProviderError => {
return new WidgetProviderError(rejected ? 4001 : 4200, message, error)
}
-/**
- * A capability-limited EIP-1193 facade over GoodWallet's active EVM session.
- * The real signer and session are private fields and cannot be retrieved by a
- * widget through this interface.
- */
export class RestrictedEip1193Provider {
readonly #allowedChainIds: ReadonlySet
readonly #allowedMethods: ReadonlySet
@@ -144,7 +135,6 @@ export class RestrictedEip1193Provider {
}
this.#signer = options.signer
- // Signing is disabled unless a Wallet-owned confirmation surface opts in.
this.#requestWalletApproval =
options.requestWalletApproval ?? (async () => false)
this.#prepareTransaction =
@@ -196,16 +186,6 @@ export class RestrictedEip1193Provider {
return this
}
- /**
- * Session updates retain the facade while notifying a widget of account loss.
- */
- updateAccount(signer: EVMSigner): void {
- this.#assertActive()
- const accountChanged = !addressesMatch(signer.address, this.#signer.address)
- this.#signer = signer
- if (accountChanged) this.#emit("accountsChanged", [signer.address])
- }
-
dispose(): void {
if (this.#revoked) return
this.#revoked = true
@@ -440,7 +420,7 @@ export class RestrictedEip1193Provider {
}
if (
rawRequest.gas !== undefined &&
- rawRequest.gasLimit !== undefined &&
+ rawRequest.gasLimit != null &&
BigInt(rawRequest.gas) !== BigInt(rawRequest.gasLimit)
) {
throw new WidgetProviderError(
diff --git a/src/widgets/provider/WidgetProvider.tsx b/src/widgets/provider/WidgetProvider.tsx
index 6c9c0e7..4ca5462 100644
--- a/src/widgets/provider/WidgetProvider.tsx
+++ b/src/widgets/provider/WidgetProvider.tsx
@@ -44,9 +44,6 @@ const requestWalletApproval = async (
return status === "accepted"
}
-/**
- * This is the sole bridge from an authenticated session into widget code.
- */
export const WidgetProvider = ({
chainIds,
requiredMethods,
diff --git a/src/widgets/provider/policy.ts b/src/widgets/provider/policy.ts
index 3074ae5..546e6c3 100644
--- a/src/widgets/provider/policy.ts
+++ b/src/widgets/provider/policy.ts
@@ -11,10 +11,6 @@ import {
XDC_CHAIN_ID,
} from "@/chain/chain-ids"
-/**
- * This central allowlist is the outer security boundary for every in-process
- * widget. Registry entries can narrow it, but cannot broaden it.
- */
export const WIDGET_READ_METHODS = new Set([
"eth_blockNumber",
"eth_call",
diff --git a/src/widgets/registry.test.ts b/src/widgets/registry.test.ts
index ac74e12..9cc5127 100644
--- a/src/widgets/registry.test.ts
+++ b/src/widgets/registry.test.ts
@@ -12,15 +12,9 @@ const widget = defineWidget({
widgetId: "goodwidget.goodreserve",
packageName: "@goodwidget/goodreserve-widget",
packageVersion: "1.0.0",
- entries: {
- react: {
- exportName: "GoodReserveWidget",
- load: async () => ({ GoodReserveWidget: () => null }),
- },
- webComponent: {
- tagName: "gw-goodreserve-widget",
- load: async () => ({ register: (tagName) => tagName ?? "unused" }),
- },
+ entry: {
+ tagName: "gw-goodreserve-widget",
+ load: async () => ({ register: (tagName) => tagName ?? "unused" }),
},
routeSlug: "goodreserve",
displayName: "GoodReserve",
@@ -32,6 +26,17 @@ const widget = defineWidget({
},
})
+const reactWidget = defineWidget({
+ ...widget,
+ widgetId: "goodwidget.react",
+ routeSlug: "react",
+ integrationMode: "react",
+ entry: {
+ exportName: "GoodReserveWidget",
+ load: async () => ({ GoodReserveWidget: () => null }),
+ },
+})
+
describe("widget registry", () => {
it("indexes typed widgets by immutable ID", () => {
expect(createWidgetRegistry([widget]).get(widget.widgetId)).toBe(widget)
@@ -40,9 +45,7 @@ describe("widget registry", () => {
it("defaults to Web Components and permits a reviewed React override", () => {
expect(DEFAULT_WIDGET_INTEGRATION_MODE).toBe("web-component")
expect(resolveWidgetIntegrationMode(widget)).toBe("web-component")
- expect(
- resolveWidgetIntegrationMode({ ...widget, integrationMode: "react" }),
- ).toBe("react")
+ expect(resolveWidgetIntegrationMode(reactWidget)).toBe("react")
})
it("rejects duplicate IDs and routes", () => {
diff --git a/src/widgets/registry.ts b/src/widgets/registry.ts
index 664e9f3..28ef92d 100644
--- a/src/widgets/registry.ts
+++ b/src/widgets/registry.ts
@@ -9,10 +9,6 @@ import {
export type WidgetIntegrationMode = "web-component" | "react"
-/**
- * Custom Elements are the normal plugin boundary; React is an explicit,
- * reviewed exception for packages which cannot expose a Custom Element.
- */
export const DEFAULT_WIDGET_INTEGRATION_MODE: WidgetIntegrationMode =
"web-component"
@@ -28,22 +24,10 @@ export type DashboardAction = {
widgetId?: string
}
-/**
- * A registry entry is reviewed source rather than remote widget metadata.
- * This prevents a package or its manifest from enlarging wallet authority.
- */
-export type RegisteredWidget = {
+type RegisteredWidgetBase = {
widgetId: `goodwidget.${string}`
packageName: `@goodwidget/${string}`
packageVersion: `${number}.${number}.${number}`
- integrationMode?: WidgetIntegrationMode
- entries: {
- react: { exportName: string; load: ReactWidgetLoader }
- webComponent: {
- tagName: `${string}-${string}`
- load: WebComponentWidgetLoader
- }
- }
routeSlug: string
displayName: string
description: string
@@ -54,6 +38,21 @@ export type RegisteredWidget = {
}
}
+export type RegisteredWidget = RegisteredWidgetBase &
+ (
+ | {
+ integrationMode?: "web-component"
+ entry: {
+ tagName: `${string}-${string}`
+ load: WebComponentWidgetLoader
+ }
+ }
+ | {
+ integrationMode: "react"
+ entry: { exportName: string; load: ReactWidgetLoader }
+ }
+ )
+
export const defineWidget = (widget: T): T =>
widget
@@ -76,9 +75,6 @@ const RESERVED_WIDGET_ROUTES = new Set([
"qr",
])
-/**
- * Validates every security-sensitive registry field before it becomes routable.
- */
const validateWidget = (widget: RegisteredWidget): void => {
if (!EXACT_PACKAGE_VERSION.test(widget.packageVersion)) {
throw new Error(
@@ -120,9 +116,6 @@ const validateWidget = (widget: RegisteredWidget): void => {
}
}
-/**
- * Creates both identity and route indexes, rejecting collisions at module load.
- */
export const createWidgetRegistry = (
widgets: readonly RegisteredWidget[],
): ReadonlyMap => {
@@ -138,23 +131,19 @@ export const createWidgetRegistry = (
if (routes.has(widget.routeSlug)) {
throw new Error(`Duplicate widget route: ${widget.routeSlug}`)
}
- if (tags.has(widget.entries.webComponent.tagName)) {
+ if (widget.integrationMode !== "react" && tags.has(widget.entry.tagName)) {
throw new Error(
- `Duplicate widget Custom Element tag: ${widget.entries.webComponent.tagName}`,
+ `Duplicate widget Custom Element tag: ${widget.entry.tagName}`,
)
}
registry.set(widget.widgetId, widget)
routes.add(widget.routeSlug)
- tags.add(widget.entries.webComponent.tagName)
+ if (widget.integrationMode !== "react") tags.add(widget.entry.tagName)
}
return registry
}
-/**
- * Add a released package only with literal import loaders and its exact version.
- * No package is registered until a reviewed widget-specific follow-up exists.
- */
export const WIDGETS: readonly RegisteredWidget[] = []
export const widgetRegistry = createWidgetRegistry(WIDGETS)
@@ -163,9 +152,6 @@ export const getWidgetByRoute = (
): RegisteredWidget | undefined =>
WIDGETS.find((widget) => widget.routeSlug === routeSlug)
-/**
- * These six action IDs preserve the existing dashboard order and behavior.
- */
export const coreDashboardActions = [
{
id: "gooddollar",
@@ -205,9 +191,6 @@ export const coreDashboardActions = [
},
] as const satisfies readonly DashboardAction[]
-/**
- * Widgets join the existing responsive action list after the six core actions.
- */
export const widgetDashboardActions = WIDGETS.map(
(widget): DashboardAction => ({
id: widget.widgetId,
diff --git a/src/widgets/resolveReactWidget.ts b/src/widgets/resolveReactWidget.ts
index 836d8fb..4c1c66b 100644
--- a/src/widgets/resolveReactWidget.ts
+++ b/src/widgets/resolveReactWidget.ts
@@ -6,9 +6,6 @@ const isReactComponent = (value: unknown): value is HostedReactWidget => {
return typeof (value as { $$typeof?: unknown }).$$typeof === "symbol"
}
-/**
- * Resolves the reviewed export name and makes stale registry exports explicit.
- */
export const resolveReactWidget = (
module: Record,
exportName: string,
diff --git a/tests-playwright/wallet-flows.e2e.ts b/tests-playwright/wallet-flows.e2e.ts
index aa12482..fed5675 100644
--- a/tests-playwright/wallet-flows.e2e.ts
+++ b/tests-playwright/wallet-flows.e2e.ts
@@ -76,7 +76,6 @@ test("captures the authenticated home balance and responsive action grid", async
await expect(page.getByText("$124.68")).toBeVisible()
const walletActions = page.getByTestId("wallet-actions")
await expect(walletActions).toBeVisible()
- // The registry-backed dashboard keeps all six core actions in their order.
await expect(walletActions.getByRole("link")).toHaveCount(6)
await expect(walletActions.getByRole("link").first()).toHaveAttribute(
"href",
From a96cfbffcb29ade83e7f1228c9acf2d6e2a9bfca Mon Sep 17 00:00:00 2001
From: blueogin
Date: Thu, 30 Jul 2026 11:01:09 -0400
Subject: [PATCH 06/11] feat: implement session storage tests and refactor
session management
- Added unit tests for session storage functionality to ensure proper handling of legacy sessions and private-key sessions.
- Refactored session management logic to clear persisted sessions and improve state handling.
- Updated session context to include masterSeed for better session management in the UI.
---
.../context/SessionContext/storage.test.ts | 48 ++++++++++++++++
src/login/context/SessionContext/storage.ts | 56 ++-----------------
src/login/hooks/context.ts | 1 +
src/sections/Options/OptionsView.tsx | 12 +---
4 files changed, 58 insertions(+), 59 deletions(-)
create mode 100644 src/login/context/SessionContext/storage.test.ts
diff --git a/src/login/context/SessionContext/storage.test.ts b/src/login/context/SessionContext/storage.test.ts
new file mode 100644
index 0000000..7584823
--- /dev/null
+++ b/src/login/context/SessionContext/storage.test.ts
@@ -0,0 +1,48 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import type { ISigner, ISignerSession } from "@/login/types"
+
+const localStorageMock = () => ({
+ getItem: vi.fn(),
+ setItem: vi.fn(),
+ removeItem: vi.fn(),
+})
+
+describe("session storage", () => {
+ beforeEach(() => {
+ vi.resetModules()
+ })
+
+ afterEach(() => {
+ vi.unstubAllGlobals()
+ })
+
+ it("purges a legacy persisted signer session on startup", async () => {
+ const storage = localStorageMock()
+ vi.stubGlobal("localStorage", storage)
+
+ await import("./storage")
+
+ expect(storage.removeItem).toHaveBeenCalledWith("SIGNER_SESSION")
+ expect(storage.getItem).not.toHaveBeenCalled()
+ })
+
+ it("keeps private-key sessions in memory only", async () => {
+ const storage = localStorageMock()
+ vi.stubGlobal("localStorage", storage)
+ const { sessionState, setSession } = await import("./storage")
+ const session: ISignerSession = {
+ type: "PRIVATE_KEY",
+ sessionOrigin: "test",
+ signer: {} as ISigner,
+ masterSeed: "secret",
+ }
+
+ setSession(session)
+
+ expect(sessionState.session).toBe(session)
+ expect(storage.setItem).not.toHaveBeenCalled()
+ expect(storage.removeItem).toHaveBeenCalledWith("SIGNER_SESSION")
+ expect(sessionState.isLoading).toBe(false)
+ })
+})
diff --git a/src/login/context/SessionContext/storage.ts b/src/login/context/SessionContext/storage.ts
index 2bd202d..9fed69a 100644
--- a/src/login/context/SessionContext/storage.ts
+++ b/src/login/context/SessionContext/storage.ts
@@ -1,43 +1,13 @@
-import type { Jsonify } from "type-fest"
import { proxy, ref } from "valtio"
-import { getPrivateKeySession } from "@/login/adapters/privatekey"
import type { Addresses, ISigner, ISignerSession } from "@/login/types"
const SIGNER_SESSION_KEY = "SIGNER_SESSION"
-export const getSessionFromLocalStorage =
- async (): Promise => {
- if (typeof localStorage === "undefined") {
- return null
- }
- const session = localStorage.getItem(SIGNER_SESSION_KEY)
- if (!session) {
- return null
- }
- const sessionJSON = JSON.parse(session) as Jsonify
- return await fromJSON(sessionJSON)
- }
-
-const fromJSON = async (
- sessionJSON: Partial>,
-): Promise => {
- switch (sessionJSON.type) {
- case "PRIVATE_KEY": {
- const { userName, profileImage, authProvider, masterSeed } = sessionJSON
- if (!masterSeed) {
- return null
- }
- return await getPrivateKeySession(
- masterSeed,
- "localStorage",
- authProvider ?? "NA",
- userName,
- profileImage,
- )
- }
+const clearPersistedSession = () => {
+ if (typeof localStorage !== "undefined") {
+ localStorage.removeItem(SIGNER_SESSION_KEY)
}
- return null
}
type SessionState = {
@@ -64,15 +34,7 @@ export const setSession = (session: ISignerSession | null) => {
sessionState.addresses = undefined
}
- if (sessionState.session) {
- localStorage.setItem(
- SIGNER_SESSION_KEY,
- JSON.stringify(sessionState.session),
- )
- } else {
- localStorage.removeItem(SIGNER_SESSION_KEY)
- }
-
+ clearPersistedSession()
sessionState.isLoading = false
}
@@ -80,11 +42,5 @@ export const logout = () => {
setSession(null)
}
-if (typeof window !== "undefined") {
- getSessionFromLocalStorage()
- .then(setSession)
- .catch((e) => {
- console.error("error getting persisted session", e)
- setSession(null)
- })
-}
+clearPersistedSession()
+sessionState.isLoading = false
diff --git a/src/login/hooks/context.ts b/src/login/hooks/context.ts
index db71aa9..51f16f1 100644
--- a/src/login/hooks/context.ts
+++ b/src/login/hooks/context.ts
@@ -10,6 +10,7 @@ import type { Addresses, ISignerSession } from "../types"
export type ISessionContext = Partial & {
addresses?: Addresses
isLoading: boolean
+ masterSeed?: string
logout?: () => void
setSession(session: ISignerSession): void
}
diff --git a/src/sections/Options/OptionsView.tsx b/src/sections/Options/OptionsView.tsx
index b7dac64..7539077 100644
--- a/src/sections/Options/OptionsView.tsx
+++ b/src/sections/Options/OptionsView.tsx
@@ -11,7 +11,6 @@ import { truncateString } from "@/components/Utils/format"
import VersionTag from "@/components/VersionTag/VersionTag"
import { type ISigner, useSessionContext } from "@/login"
import { getPrivateKeyHex } from "@/login/adapters/privatekey"
-import { getSessionFromLocalStorage } from "@/login/context/SessionContext/storage"
import OptionsMenu from "./components/OptionsMenu"
import styles from "./OptionsView.module.css"
@@ -21,14 +20,12 @@ export default function OptionsView() {
const { createToast } = useToast()
const optionsTranslations = translations.options
setBottomSheetProps({ title: optionsTranslations.title })
- const { signer, type } = useSessionContext()
+ const { signer, type, masterSeed } = useSessionContext()
const { captureEvent } = useAnalytics()
const [expanded, setExpanded] = useState(false)
const [selectedChainType, setSelectedChainType] = useState()
const handleCopyPrivateKey = async () => {
- if (!selectedChainType) return
- const session = await getSessionFromLocalStorage()
- if (!session || session.type !== "PRIVATE_KEY") return
+ if (!selectedChainType || type !== "PRIVATE_KEY" || !masterSeed) return
const status = await openDialog({
title: optionsTranslations.confirmation,
@@ -38,10 +35,7 @@ export default function OptionsView() {
})
if (status === "accepted") {
- const privateKey = await getPrivateKeyHex(
- selectedChainType,
- session.masterSeed,
- )
+ const privateKey = await getPrivateKeyHex(selectedChainType, masterSeed)
navigator.clipboard.writeText(privateKey)
captureEvent({ type: AnalyticsEventTypes.PrivateKeyCopied })
setSelectedChainType(undefined)
From 84649cdd9d6f74e7ffbf849cdb282f69483b456a Mon Sep 17 00:00:00 2001
From: blueogin
Date: Thu, 30 Jul 2026 11:09:50 -0400
Subject: [PATCH 07/11] feat: enhance wallet connect dialog management and
widget module validation
- Introduced reset functionality for wallet connect dialogs to ensure proper state management during user interactions.
- Updated widget registration logic to include metadata validation for package name and version, improving integration reliability.
- Enhanced tests for wallet connect dialogs and widget registration to cover new validation scenarios and reset behavior.
---
src/login/context/SessionContext/storage.ts | 2 +
.../store/walletConnectDialogStore.test.ts | 41 +++++++++++-
.../store/walletConnectDialogStore.ts | 57 ++++++++++++++---
src/widgets/WidgetRenderer.tsx | 4 ++
src/widgets/hostTypes.ts | 36 ++++++++++-
src/widgets/hosts/ReactWidgetHost.tsx | 16 +++--
.../hosts/WebComponentWidgetHost.test.ts | 62 ++++++++++++++++---
src/widgets/hosts/WebComponentWidgetHost.tsx | 35 ++++++++---
.../RestrictedEip1193Provider.test.ts | 13 ++++
.../provider/RestrictedEip1193Provider.ts | 11 ++--
src/widgets/registry.test.ts | 16 ++++-
src/widgets/resolveReactWidget.test.ts | 16 +++++
12 files changed, 268 insertions(+), 41 deletions(-)
diff --git a/src/login/context/SessionContext/storage.ts b/src/login/context/SessionContext/storage.ts
index 9fed69a..7df4762 100644
--- a/src/login/context/SessionContext/storage.ts
+++ b/src/login/context/SessionContext/storage.ts
@@ -1,6 +1,7 @@
import { proxy, ref } from "valtio"
import type { Addresses, ISigner, ISignerSession } from "@/login/types"
+import { resetWalletConnectDialogs } from "@/sections/WalletConnect/store/walletConnectDialogStore"
const SIGNER_SESSION_KEY = "SIGNER_SESSION"
@@ -39,6 +40,7 @@ export const setSession = (session: ISignerSession | null) => {
}
export const logout = () => {
+ resetWalletConnectDialogs()
setSession(null)
}
diff --git a/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts b/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
index b12e190..f59b28d 100644
--- a/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
+++ b/src/sections/WalletConnect/store/walletConnectDialogStore.test.ts
@@ -1,7 +1,9 @@
-import { describe, expect, it } from "vitest"
+import { afterEach, describe, expect, it, vi } from "vitest"
import {
openWalletConnectDialog,
+ resetWalletConnectDialogs,
+ updateWalletConnectDialogStatus,
walletConnectDialogStore,
} from "./walletConnectDialogStore"
@@ -13,6 +15,11 @@ const dialog = (title: string) => ({
})
describe("openWalletConnectDialog", () => {
+ afterEach(() => {
+ resetWalletConnectDialogs()
+ vi.useRealTimers()
+ })
+
it("keeps concurrent approvals bound to their own dialogs", async () => {
const first = openWalletConnectDialog(dialog("First"))
const second = openWalletConnectDialog(dialog("Second"))
@@ -26,4 +33,36 @@ describe("openWalletConnectDialog", () => {
walletConnectDialogStore.status = "rejected"
await expect(second).resolves.toBe("rejected")
})
+
+ it("rejects active and queued dialogs when reset", async () => {
+ const first = openWalletConnectDialog(dialog("First"))
+ const second = openWalletConnectDialog(dialog("Second"))
+
+ resetWalletConnectDialogs()
+
+ await expect(first).resolves.toBe("rejected")
+ await expect(second).resolves.toBe("rejected")
+
+ const next = openWalletConnectDialog(dialog("Next"))
+ expect(walletConnectDialogStore.dialog).toMatchObject({ title: "Next" })
+ walletConnectDialogStore.status = "rejected"
+ await expect(next).resolves.toBe("rejected")
+ })
+
+ it("ignores a delayed update after reset", async () => {
+ vi.useFakeTimers()
+ const first = openWalletConnectDialog(dialog("First"))
+ const update = updateWalletConnectDialogStatus("accepted")
+
+ resetWalletConnectDialogs()
+ await expect(first).resolves.toBe("rejected")
+
+ const second = openWalletConnectDialog(dialog("Second"))
+ await vi.advanceTimersByTimeAsync(200)
+ await update
+
+ expect(walletConnectDialogStore.status).toBe("pending")
+ resetWalletConnectDialogs()
+ await expect(second).resolves.toBe("rejected")
+ })
})
diff --git a/src/sections/WalletConnect/store/walletConnectDialogStore.ts b/src/sections/WalletConnect/store/walletConnectDialogStore.ts
index 7914973..2fa7d3c 100644
--- a/src/sections/WalletConnect/store/walletConnectDialogStore.ts
+++ b/src/sections/WalletConnect/store/walletConnectDialogStore.ts
@@ -50,25 +50,33 @@ type QueuedDialog = {
}
const dialogQueue: QueuedDialog[] = []
-let dialogOpen = false
+let activeDialog: QueuedDialog | undefined
+let unsubscribeActive: (() => void) | undefined
+
+const settleActiveDialog = (status: WalletConnectDialogStatus): void => {
+ const settledDialog = activeDialog
+ if (!settledDialog) return
+
+ unsubscribeActive?.()
+ unsubscribeActive = undefined
+ activeDialog = undefined
+ settledDialog.resolve(status)
+ openNextDialog()
+}
const openNextDialog = (): void => {
- if (dialogOpen) return
+ if (activeDialog) return
const queuedDialog = dialogQueue.shift()
if (!queuedDialog) return
- dialogOpen = true
+ activeDialog = queuedDialog
walletConnectDialogStore.dialog = queuedDialog.args
walletConnectDialogStore.status = "pending"
walletConnectDialogStore.exiting = false
- const unsubscribe = subscribe(walletConnectDialogStore, () => {
+ unsubscribeActive = subscribe(walletConnectDialogStore, () => {
if (walletConnectDialogStore.status === "pending") return
- const status = walletConnectDialogStore.status
- unsubscribe()
- dialogOpen = false
- queuedDialog.resolve(status)
- openNextDialog()
+ settleActiveDialog(walletConnectDialogStore.status)
})
}
@@ -80,10 +88,41 @@ export const openWalletConnectDialog = (
openNextDialog()
})
+export const resetWalletConnectDialogs = (): void => {
+ const pendingDialogs = activeDialog
+ ? [activeDialog, ...dialogQueue.splice(0)]
+ : dialogQueue.splice(0)
+
+ unsubscribeActive?.()
+ unsubscribeActive = undefined
+ activeDialog = undefined
+ walletConnectDialogStore.status = "rejected"
+ walletConnectDialogStore.exiting = false
+
+ for (const pendingDialog of pendingDialogs) {
+ pendingDialog.resolve("rejected")
+ }
+}
+
export const updateWalletConnectDialogStatus = async (
status: WalletConnectDialogStatus,
) => {
+ const dialog = activeDialog
+ if (
+ !dialog ||
+ walletConnectDialogStore.status !== "pending" ||
+ walletConnectDialogStore.exiting
+ ) {
+ return
+ }
+
walletConnectDialogStore.exiting = true
await new Promise((resolve) => setTimeout(resolve, 200))
+ if (
+ activeDialog !== dialog ||
+ walletConnectDialogStore.status !== "pending"
+ ) {
+ return
+ }
walletConnectDialogStore.status = status
}
diff --git a/src/widgets/WidgetRenderer.tsx b/src/widgets/WidgetRenderer.tsx
index c1c61a4..0b084c9 100644
--- a/src/widgets/WidgetRenderer.tsx
+++ b/src/widgets/WidgetRenderer.tsx
@@ -16,6 +16,8 @@ export const WidgetRenderer = ({
)
@@ -25,6 +27,8 @@ export const WidgetRenderer = ({
)
diff --git a/src/widgets/hostTypes.ts b/src/widgets/hostTypes.ts
index 0c162e3..496db4a 100644
--- a/src/widgets/hostTypes.ts
+++ b/src/widgets/hostTypes.ts
@@ -8,13 +8,43 @@ export type WidgetHostProps = {
config?: Record
}
-export type ReactWidgetLoader = () => Promise>
+export type WidgetModuleMetadata = {
+ packageName: string
+ packageVersion: string
+}
+
+export type WidgetModule = {
+ goodWidgetMetadata: WidgetModuleMetadata
+}
+
+export type ReactWidgetModule = Record & WidgetModule
+
+export type ReactWidgetLoader = () => Promise
export type HostedReactWidget = ComponentType
-export type WebComponentWidgetLoader = () => Promise<{
+export type WebComponentWidgetModule = WidgetModule & {
register: (tagName?: string) => string | Promise
-}>
+}
+
+export type WebComponentWidgetLoader = () => Promise
+
+export const assertWidgetModuleMetadata = (
+ module: WidgetModule,
+ packageName: string,
+ packageVersion: string,
+): void => {
+ const metadata = module.goodWidgetMetadata
+ if (
+ !metadata ||
+ metadata.packageName !== packageName ||
+ metadata.packageVersion !== packageVersion
+ ) {
+ throw new Error(
+ `Widget module identity mismatch: expected ${packageName}@${packageVersion}`,
+ )
+ }
+}
export type HostedWidgetElement = HTMLElement & {
provider: RestrictedEip1193Provider | null
diff --git a/src/widgets/hosts/ReactWidgetHost.tsx b/src/widgets/hosts/ReactWidgetHost.tsx
index a57829b..18fbe99 100644
--- a/src/widgets/hosts/ReactWidgetHost.tsx
+++ b/src/widgets/hosts/ReactWidgetHost.tsx
@@ -4,20 +4,25 @@ import { useEffect, useState } from "react"
import { LoadingSpinner } from "@/components/Snippet/LoadingSpinner"
-import type {
- HostedReactWidget,
- ReactWidgetLoader,
- WidgetHostProps,
+import {
+ assertWidgetModuleMetadata,
+ type HostedReactWidget,
+ type ReactWidgetLoader,
+ type WidgetHostProps,
} from "../hostTypes"
import { resolveReactWidget } from "../resolveReactWidget"
export const ReactWidgetHost = ({
load,
exportName,
+ packageName,
+ packageVersion,
...hostProps
}: WidgetHostProps & {
load: ReactWidgetLoader
exportName: string
+ packageName: string
+ packageVersion: string
}) => {
const [Component, setComponent] = useState(null)
const [loadError, setLoadError] = useState(null)
@@ -30,6 +35,7 @@ export const ReactWidgetHost = ({
load()
.then((module) => {
if (!isMounted) return
+ assertWidgetModuleMetadata(module, packageName, packageVersion)
const exportedComponent = resolveReactWidget(module, exportName)
setComponent(() => exportedComponent)
})
@@ -45,7 +51,7 @@ export const ReactWidgetHost = ({
return () => {
isMounted = false
}
- }, [exportName, load])
+ }, [exportName, load, packageName, packageVersion])
if (loadError) throw loadError
if (!Component) return
diff --git a/src/widgets/hosts/WebComponentWidgetHost.test.ts b/src/widgets/hosts/WebComponentWidgetHost.test.ts
index f382bf5..744daa2 100644
--- a/src/widgets/hosts/WebComponentWidgetHost.test.ts
+++ b/src/widgets/hosts/WebComponentWidgetHost.test.ts
@@ -16,24 +16,68 @@ describe("Custom Element registration", () => {
vi.stubGlobal("customElements", { define, get })
const firstLoad = vi.fn(async () => ({
+ goodWidgetMetadata: {
+ packageName: "@goodwidget/test-widget",
+ packageVersion: "1.0.0",
+ },
register: async (tagName?: string) => {
get.mockReturnValue(class {} as CustomElementConstructor)
return tagName ?? "gw-widget"
},
}))
const secondLoad = vi.fn(async () => ({
+ goodWidgetMetadata: {
+ packageName: "@goodwidget/test-widget",
+ packageVersion: "1.0.0",
+ },
register: async (tagName?: string) => tagName ?? "gw-widget",
}))
- await expect(registerElement(firstLoad, "gw-widget")).resolves.toBe(
- "gw-widget",
- )
- await expect(registerElement(firstLoad, "gw-widget")).resolves.toBe(
- "gw-widget",
- )
+ await expect(
+ registerElement(
+ firstLoad,
+ "gw-widget",
+ "@goodwidget/test-widget",
+ "1.0.0",
+ ),
+ ).resolves.toBe("gw-widget")
+ await expect(
+ registerElement(
+ firstLoad,
+ "gw-widget",
+ "@goodwidget/test-widget",
+ "1.0.0",
+ ),
+ ).resolves.toBe("gw-widget")
expect(firstLoad).toHaveBeenCalledTimes(1)
- await expect(registerElement(secondLoad, "gw-widget")).rejects.toThrow(
- "already registered",
- )
+ await expect(
+ registerElement(
+ secondLoad,
+ "gw-widget",
+ "@goodwidget/test-widget",
+ "1.0.0",
+ ),
+ ).rejects.toThrow("already registered")
+ })
+
+ it("rejects module metadata that does not match the registry", async () => {
+ const get = vi.fn(() => undefined)
+ vi.stubGlobal("customElements", { define: vi.fn(), get })
+ const load = vi.fn(async () => ({
+ goodWidgetMetadata: {
+ packageName: "@goodwidget/test-widget",
+ packageVersion: "2.0.0",
+ },
+ register: async (tagName?: string) => tagName ?? "gw-versioned-widget",
+ }))
+
+ await expect(
+ registerElement(
+ load,
+ "gw-versioned-widget",
+ "@goodwidget/test-widget",
+ "1.0.0",
+ ),
+ ).rejects.toThrow("expected @goodwidget/test-widget@1.0.0")
})
})
diff --git a/src/widgets/hosts/WebComponentWidgetHost.tsx b/src/widgets/hosts/WebComponentWidgetHost.tsx
index 4074de5..c675e7d 100644
--- a/src/widgets/hosts/WebComponentWidgetHost.tsx
+++ b/src/widgets/hosts/WebComponentWidgetHost.tsx
@@ -8,14 +8,17 @@ import {
assignHostedWidgetProperties,
clearHostedWidgetProperties,
} from "../hostProperties"
-import type {
- HostedWidgetElement,
- WebComponentWidgetLoader,
- WidgetHostProps,
+import {
+ assertWidgetModuleMetadata,
+ type HostedWidgetElement,
+ type WebComponentWidgetLoader,
+ type WidgetHostProps,
} from "../hostTypes"
type TagRegistration = {
load: WebComponentWidgetLoader
+ packageName: string
+ packageVersion: string
promise: Promise
}
@@ -24,11 +27,17 @@ const registrationCache = new Map()
export const registerElement = (
load: WebComponentWidgetLoader,
tagName: string,
+ packageName: string,
+ packageVersion: string,
): Promise => {
const existingDefinition = customElements.get(tagName)
const cached = registrationCache.get(tagName)
if (cached) {
- if (cached.load !== load) {
+ if (
+ cached.load !== load ||
+ cached.packageName !== packageName ||
+ cached.packageVersion !== packageVersion
+ ) {
return Promise.reject(
new Error(`Custom Element tag ${tagName} is already registered`),
)
@@ -43,6 +52,7 @@ export const registerElement = (
const promise = load()
.then(async (module) => {
+ assertWidgetModuleMetadata(module, packageName, packageVersion)
const registered = await module.register(tagName)
if (registered !== tagName) {
throw new Error(
@@ -59,19 +69,28 @@ export const registerElement = (
throw error
})
- registrationCache.set(tagName, { load, promise })
+ registrationCache.set(tagName, {
+ load,
+ packageName,
+ packageVersion,
+ promise,
+ })
return promise
}
export const WebComponentWidgetHost = ({
load,
tagName,
+ packageName,
+ packageVersion,
provider,
themeOverrides,
config,
}: WidgetHostProps & {
load: WebComponentWidgetLoader
tagName: string
+ packageName: string
+ packageVersion: string
}) => {
const elementRef = useRef(null)
const [registeredTagName, setRegisteredTagName] = useState(
@@ -84,7 +103,7 @@ export const WebComponentWidgetHost = ({
setRegisteredTagName(null)
setLoadError(null)
- registerElement(load, tagName)
+ registerElement(load, tagName, packageName, packageVersion)
.then((registered) => {
if (!isMounted) return
setRegisteredTagName(registered)
@@ -101,7 +120,7 @@ export const WebComponentWidgetHost = ({
return () => {
isMounted = false
}
- }, [load, tagName])
+ }, [load, packageName, packageVersion, tagName])
useEffect(() => {
const element = elementRef.current
diff --git a/src/widgets/provider/RestrictedEip1193Provider.test.ts b/src/widgets/provider/RestrictedEip1193Provider.test.ts
index d35a138..83b60f0 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.test.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.test.ts
@@ -189,6 +189,19 @@ describe("RestrictedEip1193Provider", () => {
],
}),
).rejects.toMatchObject({ code: 4100 })
+ await expect(
+ provider.request({
+ method: "eth_signTypedData_v4",
+ params: [
+ address,
+ JSON.stringify({
+ domain: { name: "Widget" },
+ types: { Thing: [{ name: "value", type: "uint256" }] },
+ message: { value: 1 },
+ }),
+ ],
+ }),
+ ).rejects.toMatchObject({ code: 4100 })
expect(requestWalletApproval).not.toHaveBeenCalled()
})
diff --git a/src/widgets/provider/RestrictedEip1193Provider.ts b/src/widgets/provider/RestrictedEip1193Provider.ts
index 058085b..3327d16 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.ts
@@ -370,10 +370,13 @@ export class RestrictedEip1193Provider {
}
const context = this.#captureSigningContext(account)
const { EIP712Domain: _domainType, ...types } = data.types
- if (
- data.domain.chainId !== undefined &&
- Number(data.domain.chainId) !== context.chainId
- ) {
+ if (data.domain.chainId === undefined) {
+ throw new WidgetProviderError(
+ 4100,
+ "Typed-data domain must declare the active widget chain",
+ )
+ }
+ if (Number(data.domain.chainId) !== context.chainId) {
throw new WidgetProviderError(
4100,
"Typed-data chain does not match the active widget chain",
diff --git a/src/widgets/registry.test.ts b/src/widgets/registry.test.ts
index 9cc5127..b8c9ab7 100644
--- a/src/widgets/registry.test.ts
+++ b/src/widgets/registry.test.ts
@@ -14,7 +14,13 @@ const widget = defineWidget({
packageVersion: "1.0.0",
entry: {
tagName: "gw-goodreserve-widget",
- load: async () => ({ register: (tagName) => tagName ?? "unused" }),
+ load: async () => ({
+ goodWidgetMetadata: {
+ packageName: "@goodwidget/goodreserve-widget",
+ packageVersion: "1.0.0",
+ },
+ register: (tagName) => tagName ?? "unused",
+ }),
},
routeSlug: "goodreserve",
displayName: "GoodReserve",
@@ -33,7 +39,13 @@ const reactWidget = defineWidget({
integrationMode: "react",
entry: {
exportName: "GoodReserveWidget",
- load: async () => ({ GoodReserveWidget: () => null }),
+ load: async () => ({
+ goodWidgetMetadata: {
+ packageName: "@goodwidget/goodreserve-widget",
+ packageVersion: "1.0.0",
+ },
+ GoodReserveWidget: () => null,
+ }),
},
})
diff --git a/src/widgets/resolveReactWidget.test.ts b/src/widgets/resolveReactWidget.test.ts
index 6269c25..48f456e 100644
--- a/src/widgets/resolveReactWidget.test.ts
+++ b/src/widgets/resolveReactWidget.test.ts
@@ -1,5 +1,6 @@
import { describe, expect, it } from "vitest"
+import { assertWidgetModuleMetadata } from "./hostTypes"
import { resolveReactWidget } from "./resolveReactWidget"
describe("React widget export resolution", () => {
@@ -38,4 +39,19 @@ describe("React widget export resolution", () => {
),
).toThrow("does not export React component GoodReserveWidget")
})
+
+ it("rejects module metadata that does not match the registry", () => {
+ expect(() =>
+ assertWidgetModuleMetadata(
+ {
+ goodWidgetMetadata: {
+ packageName: "@goodwidget/react-widget",
+ packageVersion: "2.0.0",
+ },
+ },
+ "@goodwidget/react-widget",
+ "1.0.0",
+ ),
+ ).toThrow("expected @goodwidget/react-widget@1.0.0")
+ })
})
From 1694e75e42399acbce7f6ebe3b0a9e37c9b951d6 Mon Sep 17 00:00:00 2001
From: blueogin
Date: Thu, 30 Jul 2026 17:27:58 -0400
Subject: [PATCH 08/11] fix: update wallet flow tests and improve navigation
handling
- Modified the login test to check for wallet actions visibility using test ID instead of text.
- Enhanced the claim verification test by clicking the GoodDollar link instead of directly navigating, ensuring better interaction simulation.
- Updated screenshots for various onboarding flows to reflect recent UI changes.
---
.../desktop/home-balances-overflow-en.png | Bin 49240 -> 50622 bytes
.../desktop/login-onboarding-da.png | Bin 36300 -> 37058 bytes
.../mobile/login-onboarding-da.png | Bin 113960 -> 113918 bytes
tests-playwright/wallet-flows.e2e.ts | 11 +++++------
4 files changed, 5 insertions(+), 6 deletions(-)
diff --git a/tests-playwright/screenshots/desktop/home-balances-overflow-en.png b/tests-playwright/screenshots/desktop/home-balances-overflow-en.png
index 4834f2d44911c99a8bbae999833229ec28e939fd..8b9365eb3c171d185449f7854eacc2468b1e31e6 100644
GIT binary patch
literal 50622
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